/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using ForwardWindow3Stride2 = WindowStrideTest<Pair, 3, 2>;
TYPED_TEST_SUITE(ForwardWindow3Stride2, GTestTypeTriples);
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {128., 241., 184., 441., 681.,
                                         453., 320., 457., 280.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 501., 861., 951.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {240., 256., 449.,  482.,  340., 368.,
                                         813., 882., 1245., 1362., 819., 906.,
                                         564., 640., 791.,  914.,  472., 560.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {759.,  822.,  921.,  1002.,
                                         1569., 1722., 1731., 1902.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,  480.,  496.,  512.,  865.,  898.,  931.,  964.,  652.,
      680.,  708.,  736.,  1557., 1626., 1695., 1764., 2373., 2490.,
      2607., 2724., 1551., 1638., 1725., 1812., 1052., 1128., 1204.,
      1280., 1459., 1582., 1705., 1828., 856.,  944.,  1032., 1120.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1761., 1842., 1923., 2004.,
      2985., 3138., 3291., 3444., 3291., 3462., 3633., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {940.,  1790., 1372., 3330., 5133.,
                                         3402., 2380., 3374., 2044.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081., 3765., 6501., 7185.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820.,  1880., 3454., 3580., 2636., 2744., 6390., 6660., 9807.,
      10266., 6462., 6804., 4460., 4760., 6262., 6748., 3740., 4088.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5919.,  6162.,  7215.,  7530.,
                                         12399., 13002., 13695., 14370.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,  3640.,  3700.,  3760.,  6782.,  6908.,  7034.,  7160.,  5164.,
      5272.,  5380.,  5488.,  12510., 12780., 13050., 13320., 19155., 19614.,
      20073., 20532., 12582., 12924., 13266., 13608., 8620.,  8920.,  9220.,
      9520.,  12038., 12524., 13010., 13496., 7132.,  7480.,  7828.,  8176.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 14115., 14430., 14745., 15060.,
      24195., 24798., 25401., 26004., 26715., 27390., 28065., 28740.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7192.,  13780., 10584., 25860., 39822.,
                                         26340., 18328., 25876., 15576.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838., 29166., 50478., 55806.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152., 14384., 27068., 27560., 20744., 21168., 50652., 51720., 77826.,
      79644., 51324., 52680., 35464., 36656., 49820., 51752., 29768., 31152.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46722., 47676.,  57090.,  58332.,
                                         98562., 100956., 108930., 111612.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  53644.,  54136.,  54628.,  55120.,
      41064.,  41488.,  41912.,  42336.,  100236., 101304., 102372., 103440.,
      153834., 155652., 157470., 159288., 101292., 102648., 104004., 105360.,
      69736.,  70928.,  72120.,  73312.,  97708.,  99640.,  101572., 103504.,
      58152.,  59536.,  60920.,  62304.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  112938., 114180., 115422., 116664.,
      194730., 197124., 199518., 201912., 215178., 217860., 220542., 223224.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {226., 304., 223., 744., 834.,
                                         546., 514., 556., 337.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474., 564., 1014., 1104.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      422.,  452., 566.,  608., 412.,  446., 1362., 1488., 1524.,
      1668., 987., 1092., 890., 1028., 962., 1112., 568.,  674.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {876.,  948.,  1038., 1128.,
                                         1848., 2028., 2010., 2208.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      814.,  844.,  874.,  904.,  1090., 1132., 1174., 1216., 790.,
      824.,  858.,  892.,  2598., 2724., 2850., 2976., 2904., 3048.,
      3192., 3336., 1869., 1974., 2079., 2184., 1642., 1780., 1918.,
      2056., 1774., 1924., 2074., 2224., 1030., 1136., 1242., 1348.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256.,
      3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1676., 2276., 1672., 5619., 6303.,
                                         4110., 3800., 4112., 2464.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567., 4251., 7671., 8355.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3238.,  3352., 4390., 4552., 3212., 3344., 10743., 11238., 12039.,
      12606., 7806., 8220., 7054., 7600., 7630., 8224.,  4508.,  4928.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6855.,  7134.,  8151.,  8502.,
                                         14631., 15342., 15927., 16710.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6362.,  6476.,  6590.,  6704.,  8618.,  8780.,  8942.,  9104.,  6292.,
      6424.,  6556.,  6688.,  20991., 21486., 21981., 22476., 23511., 24078.,
      24645., 25212., 15198., 15612., 16026., 16440., 13562., 14108., 14654.,
      15200., 14666., 15260., 15854., 16448., 8596.,  9016.,  9436.,  9856.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 15951., 16302., 16653., 17004.,
      28551., 29262., 29973., 30684., 31071., 31854., 32637., 33420.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12892., 17596., 12936., 43638., 48966.,
                                         31860., 29164., 31564., 18792.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654., 32982., 59622., 64950.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25340., 25784., 34556., 35192., 25352., 25872., 85314., 87276., 95682.,
      97932., 62076., 63720., 56156., 58328., 60764., 63128., 35912., 37584.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {54210.,  55308.,  64578.,  65964.,
                                         116418., 119244., 126786., 129900.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50236.,  50680.,  51124.,  51568.,  68476.,  69112.,  69748.,  70384.,
      50184.,  50704.,  51224.,  51744.,  168666., 170628., 172590., 174552.,
      189114., 191364., 193614., 195864., 122508., 124152., 125796., 127440.,
      110140., 112312., 114484., 116656., 119164., 121528., 123892., 126256.,
      70152.,  71824.,  73496.,  75168.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 127770., 129156., 130542., 131928.,
      230010., 232836., 235662., 238488., 250458., 253572., 256686., 259800.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {274.,  352., 430., 301., 960., 1050.,
                                         1140., 732., 670., 712., 754., 451.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600., 690., 780., 1320., 1410., 1500.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      512.,  548.,  656.,  704.,  800.,  860.,  556.,  602.,
      1758., 1920., 1920., 2100., 2082., 2280., 1323., 1464.,
      1160., 1340., 1232., 1424., 1304., 1508., 760.,  902.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1110., 1200., 1272., 1380.,
                                         1434., 1560., 2406., 2640.,
                                         2568., 2820., 2730., 3000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      988.,  1024., 1060., 1096., 1264., 1312., 1360., 1408., 1540., 1600.,
      1660., 1720., 1066., 1112., 1158., 1204., 3354., 3516., 3678., 3840.,
      3660., 3840., 4020., 4200., 3966., 4164., 4362., 4560., 2505., 2646.,
      2787., 2928., 2140., 2320., 2500., 2680., 2272., 2464., 2656., 2848.,
      2404., 2608., 2812., 3016., 1378., 1520., 1662., 1804.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760.,
      2742., 2868., 2994., 3120., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2048., 2648., 3248., 2272.,
                                         7275., 7959., 8643., 5526.,
                                         4964., 5276., 5588., 3304.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4539.,  5223.,  5907.,
                                         10011., 10695., 11379.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3958.,  4096.,  5110.,  5296.,  6262.,  6496.,  4364.,  4544.,
      13911., 14550., 15207., 15918., 16503., 17286., 10494., 11052.,
      9214.,  9928.,  9790.,  10552., 10366., 11176., 6044.,  6608.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8727.,  9078.,  10023., 10446.,
                                         11319., 11814., 19095., 20022.,
                                         20391., 21390., 21687., 22758.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7778.,  7916.,  8054.,  8192.,  10034., 10220., 10406., 10592.,
      12290., 12524., 12758., 12992., 8548.,  8728.,  8908.,  9088.,
      27183., 27822., 28461., 29100., 29703., 30414., 31125., 31836.,
      32223., 33006., 33789., 34572., 20430., 20988., 21546., 22104.,
      17714., 18428., 19142., 19856., 18818., 19580., 20342., 21104.,
      19922., 20732., 21542., 22352., 11524., 12088., 12652., 13216.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103., 17454., 17805., 18156., 19623., 20046., 20469., 20892.,
      22143., 22638., 23133., 23628., 37263., 38190., 39117., 40044.,
      39783., 40782., 41781., 42780., 42303., 43374., 44445., 45516.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15820., 20524., 25228., 17640.,
                                         56598., 61926., 67254., 42900.,
                                         38140., 40540., 42940., 25224.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35286., 40614., 45942.,
                                         77910., 83238., 88566.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31100.,  31640.,  40316.,  41048.,  49532.,  50456.,  34568., 35280.,
      110658., 113196., 121026., 123852., 131394., 134508., 83580., 85800.,
      73436.,  76280.,  78044.,  81080.,  82652.,  85880.,  48200., 50448.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {69186.,  70572.,  79554.,  81228.,
                                         89922.,  91884.,  152130., 155820.,
                                         162498., 166476., 172866., 177132.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61660.,  62200.,  62740.,  63280.,  79900.,  80632.,  81364.,  82096.,
      98140.,  99064.,  99988.,  100912., 68424.,  69136.,  69848.,  70560.,
      218778., 221316., 223854., 226392., 239226., 242052., 244878., 247704.,
      259674., 262788., 265902., 269016., 164940., 167160., 169380., 171600.,
      144028., 146872., 149716., 152560., 153052., 156088., 159124., 162160.,
      162076., 165304., 168532., 171760., 94152.,  96400.,  98648.,  100896.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986., 138372., 139758., 141144., 157434., 159108., 160782., 162456.,
      177882., 179844., 181806., 183768., 300570., 304260., 307950., 311640.,
      321018., 324996., 328974., 332952., 341466., 345732., 349998., 354264.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {276., 456., 318., 606., 906.,
                                         588., 400., 562., 340.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 501., 861., 951.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912., 579., 636., 1113., 1212., 1650.,
      1812., 1059., 1176., 704., 800., 971., 1124., 572.,  680.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {759.,  822.,  921.,  1002.,
                                         1569., 1722., 1731., 1902.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,  1026., 1065., 1104., 1608., 1680., 1752., 1824., 1101.,
      1158., 1215., 1272., 2127., 2226., 2325., 2424., 3138., 3300.,
      3462., 3624., 2001., 2118., 2235., 2352., 1312., 1408., 1504.,
      1600., 1789., 1942., 2095., 2248., 1036., 1144., 1252., 1360.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1761., 1842., 1923., 2004.,
      2985., 3138., 3291., 3444., 3291., 3462., 3633., 3804.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2070., 3423., 2382., 4590., 6843.,
                                         4422., 2980., 4154., 2484.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081., 3765., 6501., 7185.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3990.,  4140., 6567., 6846., 4542., 4764., 8790., 9180., 13047.,
      13686., 8382., 8844., 5580., 5960., 7702., 8308., 4540., 4968.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5919.,  6162.,  7215.,  7530.,
                                         12399., 13002., 13695., 14370.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7830.,  7980.,  8130.,  8280.,  12855., 13134., 13413., 13692., 8862.,
      9084.,  9306.,  9528.,  17190., 17580., 17970., 18360., 25455., 26094.,
      26733., 27372., 16302., 16764., 17226., 17688., 10780., 11160., 11540.,
      11920., 14798., 15404., 16010., 16616., 8652.,  9080.,  9508.,  9936.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 14115., 14430., 14745., 15060.,
      24195., 24798., 25401., 26004., 26715., 27390., 28065., 28740.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16020., 26502., 18420., 35700., 53142.,
                                         34260., 22968., 31876., 18936.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838., 29166., 50478., 55806.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31452.,  32040., 51906., 53004., 35964., 36840., 69852., 71400., 103746.,
      106284., 66684., 68520., 44424., 45936., 61340., 63752., 36168., 37872.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46722., 47676.,  57090.,  58332.,
                                         98562., 100956., 108930., 111612.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62316.,  62904.,  63492.,  64080.,  102714., 103812., 104910., 106008.,
      71052.,  71928.,  72804.,  73680.,  138156., 139704., 141252., 142800.,
      204954., 207492., 210030., 212568., 131532., 133368., 135204., 137040.,
      87336.,  88848.,  90360.,  91872.,  120268., 122680., 125092., 127504.,
      70632.,  72336.,  74040.,  75744.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  112938., 114180., 115422., 116664.,
      194730., 197124., 199518., 201912., 215178., 217860., 220542., 223224.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474., 564., 384., 1014., 1104.,
                                         708., 640., 682., 409.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474., 564., 1014., 1104.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 699.,  768.,  1848., 2028., 2010.,
      2208., 1275., 1416., 1106., 1280., 1178., 1364., 688.,  818.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {876.,  948.,  1038., 1128.,
                                         1848., 2028., 2010., 2208.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256., 1329.,
      1398., 1467., 1536., 3516., 3696., 3876., 4056., 3822., 4020.,
      4218., 4416., 2409., 2550., 2691., 2832., 2038., 2212., 2386.,
      2560., 2170., 2356., 2542., 2728., 1246., 1376., 1506., 1636.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256.,
      3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567., 4251., 2886., 7671., 8355.,
                                         5334., 4736., 5048., 2992.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567., 4251., 7671., 8355.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  8151.,  8502., 5502., 5772., 14631., 15342., 15927.,
      16710., 10110., 10668., 8782., 9472., 9358., 10096., 5468.,  5984.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6855.,  7134.,  8151.,  8502.,
                                         14631., 15342., 15927., 16710.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 15951., 16302., 16653., 17004., 10734.,
      11004., 11274., 11544., 28551., 29262., 29973., 30684., 31071., 31854.,
      32637., 33420., 19662., 20220., 20778., 21336., 16874., 17564., 18254.,
      18944., 17978., 18716., 19454., 20192., 10420., 10936., 11452., 11968.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 15951., 16302., 16653., 17004.,
      28551., 29262., 29973., 30684., 31071., 31854., 32637., 33420.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654., 32982., 22356., 59622., 64950.,
                                         41364., 36364., 38764., 22824.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654., 32982., 59622., 64950.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  64578.,  65964.,  43644., 44712.,
      116418., 119244., 126786., 129900., 80508., 82728.,
      69980.,  72728.,  74588.,  77528.,  43592., 45648.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {54210.,  55308.,  64578.,  65964.,
                                         116418., 119244., 126786., 129900.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 127770., 129156., 130542., 131928.,
      86220.,  87288.,  88356.,  89424.,  230010., 232836., 235662., 238488.,
      250458., 253572., 256686., 259800., 158796., 161016., 163236., 165456.,
      137212., 139960., 142708., 145456., 146236., 149176., 152116., 155056.,
      85128.,  87184.,  89240.,  91296.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 127770., 129156., 130542., 131928.,
      230010., 232836., 235662., 238488., 250458., 253572., 256686., 259800.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600.,  690., 780., 516., 1320., 1410.,
                                         1500., 948., 838., 880., 922.,  547.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600., 690., 780., 1320., 1410., 1500.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 939.,  1032.,
      2406., 2640., 2568., 2820., 2730., 3000., 1707., 1896.,
      1448., 1676., 1520., 1760., 1592., 1844., 920.,  1094.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1110., 1200., 1272., 1380.,
                                         1434., 1560., 2406., 2640.,
                                         2568., 2820., 2730., 3000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760., 2742., 2868.,
      2994., 3120., 1785., 1878., 1971., 2064., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000., 3225., 3414.,
      3603., 3792., 2668., 2896., 3124., 3352., 2800., 3040., 3280., 3520.,
      2932., 3184., 3436., 3688., 1666., 1840., 2014., 2188.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760.,
      2742., 2868., 2994., 3120., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4539.,  5223.,  5907.,  3894.,
                                         10011., 10695., 11379., 7158.,
                                         6212.,  6524.,  6836.,  4008.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4539.,  5223.,  5907.,
                                         10011., 10695., 11379.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,  9078.,  10023., 10446., 11319., 11814., 7422.,  7788.,
      19095., 20022., 20391., 21390., 21687., 22758., 13566., 14316.,
      11518., 12424., 12094., 13048., 12670., 13672., 7324.,  8016.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8727.,  9078.,  10023., 10446.,
                                         11319., 11814., 19095., 20022.,
                                         20391., 21390., 21687., 22758.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103., 17454., 17805., 18156., 19623., 20046., 20469., 20892.,
      22143., 22638., 23133., 23628., 14478., 14844., 15210., 15576.,
      37263., 38190., 39117., 40044., 39783., 40782., 41781., 42780.,
      42303., 43374., 44445., 45516., 26382., 27132., 27882., 28632.,
      22130., 23036., 23942., 24848., 23234., 24188., 25142., 26096.,
      24338., 25340., 26342., 27344., 13956., 14648., 15340., 16032.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103., 17454., 17805., 18156., 19623., 20046., 20469., 20892.,
      22143., 22638., 23133., 23628., 37263., 38190., 39117., 40044.,
      39783., 40782., 41781., 42780., 42303., 43374., 44445., 45516.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35286., 40614., 45942., 30228.,
                                         77910., 83238., 88566., 55572.,
                                         47740., 50140., 52540., 30600.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35286., 40614., 45942.,
                                         77910., 83238., 88566.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,  59004.,  60456.,
      152130., 155820., 162498., 166476., 172866., 177132., 108156., 111144.,
      91868.,  95480.,  96476.,  100280., 101084., 105080., 58440.,  61200.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {69186.,  70572.,  79554.,  81228.,
                                         89922.,  91884.,  152130., 155820.,
                                         162498., 166476., 172866., 177132.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986., 138372., 139758., 141144., 157434., 159108., 160782., 162456.,
      177882., 179844., 181806., 183768., 116556., 118008., 119460., 120912.,
      300570., 304260., 307950., 311640., 321018., 324996., 328974., 332952.,
      341466., 345732., 349998., 354264., 213324., 216312., 219300., 222288.,
      180124., 183736., 187348., 190960., 189148., 192952., 196756., 200560.,
      198172., 202168., 206164., 210160., 114120., 116880., 119640., 122400.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986., 138372., 139758., 141144., 157434., 159108., 160782., 162456.,
      177882., 179844., 181806., 183768., 300570., 304260., 307950., 311640.,
      321018., 324996., 328974., 332952., 341466., 345732., 349998., 354264.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {276., 456.,  318., 606., 906., 588.,
                                         936., 1356., 858., 560., 772., 460.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 501., 861., 951., 1311., 1401.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912.,  579.,  636.,  1113., 1212.,
      1650., 1812., 1059., 1176., 1713., 1872., 2460., 2712.,
      1539., 1716., 984.,  1120., 1331., 1544., 772.,  920.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {759.,  822.,  921.,  1002.,
                                         1569., 1722., 1731., 1902.,
                                         2379., 2622., 2541., 2802.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,  1026., 1065., 1104., 1608., 1680., 1752., 1824., 1101., 1158.,
      1215., 1272., 2127., 2226., 2325., 2424., 3138., 3300., 3462., 3624.,
      2001., 2118., 2235., 2352., 3267., 3426., 3585., 3744., 4668., 4920.,
      5172., 5424., 2901., 3078., 3255., 3432., 1832., 1968., 2104., 2240.,
      2449., 2662., 2875., 3088., 1396., 1544., 1692., 1840.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1761., 1842., 1923., 2004.,
      2985., 3138., 3291., 3444., 3291., 3462., 3633., 3804.,
      4515., 4758., 5001., 5244., 4821., 5082., 5343., 5604.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2070., 3423., 2382., 4590.,
                                         6843., 4422., 7110., 10263.,
                                         6462., 4180., 5714., 3364.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081., 3765., 6501.,
                                         7185., 9921., 10605.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3990.,  4140.,  6567., 6846., 4542.,  4764.,  8790.,  9180.,
      13047., 13686., 8382., 8844., 13590., 14220., 19527., 20526.,
      12222., 12924., 7820., 8360., 10582., 11428., 6140.,  6728.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5919.,  6162.,  7215.,  7530.,
                                         12399., 13002., 13695., 14370.,
                                         18879., 19842., 20175., 21210.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7830.,  7980.,  8130.,  8280.,  12855., 13134., 13413., 13692.,
      8862.,  9084.,  9306.,  9528.,  17190., 17580., 17970., 18360.,
      25455., 26094., 26733., 27372., 16302., 16764., 17226., 17688.,
      26550., 27180., 27810., 28440., 38055., 39054., 40053., 41052.,
      23742., 24444., 25146., 25848., 15100., 15640., 16180., 16720.,
      20318., 21164., 22010., 22856., 11692., 12280., 12868., 13456.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 14115., 14430., 14745., 15060.,
      24195., 24798., 25401., 26004., 26715., 27390., 28065., 28740.,
      36795., 37758., 38721., 39684., 39315., 40350., 41385., 42420.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16020., 26502., 18420., 35700.,
                                         53142., 34260., 55380., 79782.,
                                         50100., 32248., 43876., 25656.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838., 29166., 50478.,
                                         55806., 77118., 82446.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31452.,  32040.,  51906., 53004., 35964.,  36840.,  69852.,  71400.,
      103746., 106284., 66684., 68520., 108252., 110760., 155586., 159564.,
      97404.,  100200., 62344., 64496., 84380.,  87752.,  48968.,  51312.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46722.,  47676.,  57090.,  58332.,
                                         98562.,  100956., 108930., 111612.,
                                         150402., 154236., 160770., 164892.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62316.,  62904.,  63492.,  64080.,  102714., 103812., 104910., 106008.,
      71052.,  71928.,  72804.,  73680.,  138156., 139704., 141252., 142800.,
      204954., 207492., 210030., 212568., 131532., 133368., 135204., 137040.,
      213996., 216504., 219012., 221520., 307194., 311172., 315150., 319128.,
      192012., 194808., 197604., 200400., 122536., 124688., 126840., 128992.,
      165388., 168760., 172132., 175504., 95592.,  97936.,  100280., 102624.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  112938., 114180., 115422., 116664.,
      194730., 197124., 199518., 201912., 215178., 217860., 220542., 223224.,
      296970., 300804., 304638., 308472., 317418., 321540., 325662., 329784.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564., 384.,  1014.,
                                         1104., 708., 1554., 1644.,
                                         1032., 892., 934.,  553.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564.,  1014.,
                                         1104., 1554., 1644.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 699.,  768.,  1848., 2028.,
      2010., 2208., 1275., 1416., 2820., 3108., 2982., 3288.,
      1851., 2064., 1538., 1784., 1610., 1868., 928.,  1106.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {876.,  948.,  1038., 1128.,
                                         1848., 2028., 2010., 2208.,
                                         2820., 3108., 2982., 3288.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256., 1329., 1398.,
      1467., 1536., 3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.,
      2409., 2550., 2691., 2832., 5352., 5640., 5928., 6216., 5658., 5964.,
      6270., 6576., 3489., 3702., 3915., 4128., 2830., 3076., 3322., 3568.,
      2962., 3220., 3478., 3736., 1678., 1856., 2034., 2212.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1986., 2076., 2166., 2256.,
      3516., 3696., 3876., 4056., 3822., 4020., 4218., 4416.,
      5352., 5640., 5928., 6216., 5658., 5964., 6270., 6576.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567., 4251., 2886.,  7671.,
                                         8355., 5334., 11775., 12459.,
                                         7782., 6608., 6920.,  4048.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567., 4251.,  7671.,
                                         8355., 11775., 12459.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  8151.,  8502.,  5502.,  5772.,  14631., 15342.,
      15927., 16710., 10110., 10668., 22407., 23550., 23703., 24918.,
      14718., 15564., 12238., 13216., 12814., 13840., 7388.,  8096.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6855.,  7134.,  8151.,  8502.,
                                         14631., 15342., 15927., 16710.,
                                         22407., 23550., 23703., 24918.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 15951., 16302., 16653., 17004.,
      10734., 11004., 11274., 11544., 28551., 29262., 29973., 30684.,
      31071., 31854., 32637., 33420., 19662., 20220., 20778., 21336.,
      43671., 44814., 45957., 47100., 46191., 47406., 48621., 49836.,
      28590., 29436., 30282., 31128., 23498., 24476., 25454., 26432.,
      24602., 25628., 26654., 27680., 14068., 14776., 15484., 16192.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 15951., 16302., 16653., 17004.,
      28551., 29262., 29973., 30684., 31071., 31854., 32637., 33420.,
      43671., 44814., 45957., 47100., 46191., 47406., 48621., 49836.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654., 32982., 22356., 59622.,
                                         64950., 41364., 91590., 96918.,
                                         60372., 50764., 53164., 30888.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654., 32982., 59622.,
                                         64950., 91590., 96918.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  64578., 65964.,  43644.,  44712.,  116418., 119244.,
      126786., 129900., 80508., 82728.,  178626., 183180., 188994., 193836.,
      117372., 120744., 97628., 101528., 102236., 106328., 58952.,  61776.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {54210.,  55308.,  64578.,  65964.,
                                         116418., 119244., 126786., 129900.,
                                         178626., 183180., 188994., 193836.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 127770., 129156., 130542., 131928.,
      86220.,  87288.,  88356.,  89424.,  230010., 232836., 235662., 238488.,
      250458., 253572., 256686., 259800., 158796., 161016., 163236., 165456.,
      352698., 357252., 361806., 366360., 373146., 377988., 382830., 387672.,
      231372., 234744., 238116., 241488., 191356., 195256., 199156., 203056.,
      200380., 204472., 208564., 212656., 115080., 117904., 120728., 123552.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 127770., 129156., 130542., 131928.,
      230010., 232836., 235662., 238488., 250458., 253572., 256686., 259800.,
      352698., 357252., 361806., 366360., 373146., 377988., 382830., 387672.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  516.,  1320., 1410., 1500., 948.,
      2040., 2130., 2220., 1380., 1174., 1216., 1258., 739.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {600.,  690.,  780.,  1320., 1410.,
                                         1500., 2040., 2130., 2220.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 939.,  1032.,
      2406., 2640., 2568., 2820., 2730., 3000., 1707., 1896.,
      3702., 4080., 3864., 4260., 4026., 4440., 2475., 2760.,
      2024., 2348., 2096., 2432., 2168., 2516., 1240., 1478.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 2406., 2640., 2568.,
      2820., 2730., 3000., 3702., 4080., 3864., 4260., 4026., 4440.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760., 2742., 2868.,
      2994., 3120., 1785., 1878., 1971., 2064., 4578., 4812., 5046., 5280.,
      4884., 5136., 5388., 5640., 5190., 5460., 5730., 6000., 3225., 3414.,
      3603., 3792., 7026., 7404., 7782., 8160., 7332., 7728., 8124., 8520.,
      7638., 8052., 8466., 8880., 4665., 4950., 5235., 5520., 3724., 4048.,
      4372., 4696., 3856., 4192., 4528., 4864., 3988., 4336., 4684., 5032.,
      2242., 2480., 2718., 2956.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130., 2220., 2310., 2400., 2436., 2544., 2652., 2760., 2742.,
      2868., 2994., 3120., 4578., 4812., 5046., 5280., 4884., 5136.,
      5388., 5640., 5190., 5460., 5730., 6000., 7026., 7404., 7782.,
      8160., 7332., 7728., 8124., 8520., 7638., 8052., 8466., 8880.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4539.,  5223.,  5907.,  3894.,  10011., 10695., 11379., 7158.,
      15483., 16167., 16851., 10422., 8708.,  9020.,  9332.,  5416.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4539.,  5223.,  5907.,  10011., 10695.,
                                         11379., 15483., 16167., 16851.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,  9078.,  10023., 10446., 11319., 11814., 7422.,  7788.,
      19095., 20022., 20391., 21390., 21687., 22758., 13566., 14316.,
      29463., 30966., 30759., 32334., 32055., 33702., 19710., 20844.,
      16126., 17416., 16702., 18040., 17278., 18664., 9884.,  10832.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,  9078.,  10023., 10446., 11319., 11814., 19095., 20022., 20391.,
      21390., 21687., 22758., 29463., 30966., 30759., 32334., 32055., 33702.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103., 17454., 17805., 18156., 19623., 20046., 20469., 20892.,
      22143., 22638., 23133., 23628., 14478., 14844., 15210., 15576.,
      37263., 38190., 39117., 40044., 39783., 40782., 41781., 42780.,
      42303., 43374., 44445., 45516., 26382., 27132., 27882., 28632.,
      57423., 58926., 60429., 61932., 59943., 61518., 63093., 64668.,
      62463., 64110., 65757., 67404., 38286., 39420., 40554., 41688.,
      30962., 32252., 33542., 34832., 32066., 33404., 34742., 36080.,
      33170., 34556., 35942., 37328., 18820., 19768., 20716., 21664.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103., 17454., 17805., 18156., 19623., 20046., 20469., 20892., 22143.,
      22638., 23133., 23628., 37263., 38190., 39117., 40044., 39783., 40782.,
      41781., 42780., 42303., 43374., 44445., 45516., 57423., 58926., 60429.,
      61932., 59943., 61518., 63093., 64668., 62463., 64110., 65757., 67404.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35286.,  40614.,  45942.,  30228., 77910., 83238., 88566., 55572.,
      120534., 125862., 131190., 80916., 66940., 69340., 71740., 41352.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35286.,  40614.,  45942.,
                                         77910.,  83238.,  88566.,
                                         120534., 125862., 131190.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,  59004.,  60456.,
      152130., 155820., 162498., 166476., 172866., 177132., 108156., 111144.,
      235074., 241068., 245442., 251724., 255810., 262380., 157308., 161832.,
      128732., 133880., 133340., 138680., 137948., 143480., 78920.,  82704.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,
      152130., 155820., 162498., 166476., 172866., 177132.,
      235074., 241068., 245442., 251724., 255810., 262380.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986., 138372., 139758., 141144., 157434., 159108., 160782., 162456.,
      177882., 179844., 181806., 183768., 116556., 118008., 119460., 120912.,
      300570., 304260., 307950., 311640., 321018., 324996., 328974., 332952.,
      341466., 345732., 349998., 354264., 213324., 216312., 219300., 222288.,
      464154., 470148., 476142., 482136., 484602., 490884., 497166., 503448.,
      505050., 511620., 518190., 524760., 310092., 314616., 319140., 323664.,
      252316., 257464., 262612., 267760., 261340., 266680., 272020., 277360.,
      270364., 275896., 281428., 286960., 154056., 157840., 161624., 165408.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986., 138372., 139758., 141144., 157434., 159108., 160782., 162456.,
      177882., 179844., 181806., 183768., 300570., 304260., 307950., 311640.,
      321018., 324996., 328974., 332952., 341466., 345732., 349998., 354264.,
      464154., 470148., 476142., 482136., 484602., 490884., 497166., 503448.,
      505050., 511620., 518190., 524760.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128.,  241.,  184.,  441.,  681.,  453.,  320.,  457.,  280.,
      828.,  1216., 784.,  1266., 1806., 1128., 720.,  982.,  580.,
      1528., 2191., 1384., 2091., 2931., 1803., 1120., 1507., 880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411.,  501.,  861.,  951.,
                                         1536., 1626., 1986., 2076.,
                                         2661., 2751., 3111., 3201.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  256.,  449.,  482.,  340.,  368.,  813.,  882.,  1245.,
      1362., 819.,  906.,  564.,  640.,  791.,  914.,  472.,  560.,
      1540., 1656., 2249., 2432., 1440., 1568., 2313., 2532., 3270.,
      3612., 2019., 2256., 1264., 1440., 1691., 1964., 972.,  1160.,
      2840., 3056., 4049., 4382., 2540., 2768., 3813., 4182., 5295.,
      5862., 3219., 3606., 1964., 2240., 2591., 3014., 1472., 1760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  921.,  1002., 1569., 1722., 1731., 1902.,
      2784., 3072., 2946., 3252., 3594., 3972., 3756., 4152.,
      4809., 5322., 4971., 5502., 5619., 6222., 5781., 6402.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,   480.,   496.,  512.,  865.,  898.,  931.,  964.,  652.,   680.,
      708.,   736.,   1557., 1626., 1695., 1764., 2373., 2490., 2607.,  2724.,
      1551.,  1638.,  1725., 1812., 1052., 1128., 1204., 1280., 1459.,  1582.,
      1705.,  1828.,  856.,  944.,  1032., 1120., 2964., 3080., 3196.,  3312.,
      4315.,  4498.,  4681., 4864., 2752., 2880., 3008., 3136., 4407.,  4626.,
      4845.,  5064.,  6198., 6540., 6882., 7224., 3801., 4038., 4275.,  4512.,
      2352.,  2528.,  2704., 2880., 3109., 3382., 3655., 3928., 1756.,  1944.,
      2132.,  2320.,  5464., 5680., 5896., 6112., 7765., 8098., 8431.,  8764.,
      4852.,  5080.,  5308., 5536., 7257., 7626., 7995., 8364., 10023., 10590.,
      11157., 11724., 6051., 6438., 6825., 7212., 3652., 3928., 4204.,  4480.,
      4759.,  5182.,  5605., 6028., 2656., 2944., 3232., 3520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1761.,  1842.,  1923.,  2004.,
      2985.,  3138.,  3291.,  3444.,  3291.,  3462.,  3633.,  3804.,
      5280.,  5568.,  5856.,  6144.,  5586.,  5892.,  6198.,  6504.,
      6810.,  7188.,  7566.,  7944.,  7116.,  7512.,  7908.,  8304.,
      9105.,  9618.,  10131., 10644., 9411.,  9942.,  10473., 11004.,
      10635., 11238., 11841., 12444., 10941., 11562., 12183., 12804.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      940.,   1790.,  1372.,  3330.,  5133.,  3402.,  2380., 3374.,  2044.,
      6340.,  9290.,  5972.,  9630.,  13683., 8502.,  5380., 7274.,  4244.,
      11740., 16790., 10572., 15930., 22233., 13602., 8380., 11174., 6444.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081.,  3765.,  6501.,  7185.,
                                         11631., 12315., 15051., 15735.,
                                         20181., 20865., 23601., 24285.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820.,  1880.,  3454.,  3580.,  2636.,  2744.,  6390.,  6660.,  9807.,
      10266., 6462.,  6804.,  4460.,  4760.,  6262.,  6748.,  3740.,  4088.,
      12220., 12680., 17854., 18580., 11436., 11944., 18390., 19260., 26007.,
      27366., 16062., 17004., 10060., 10760., 13462., 14548., 7740.,  8488.,
      22620., 23480., 32254., 33580., 20236., 21144., 30390., 31860., 42207.,
      44466., 25662., 27204., 15660., 16760., 20662., 22348., 11740., 12888.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  7215.,  7530.,  12399., 13002., 13695., 14370.,
      22119., 23262., 23415., 24630., 28599., 30102., 29895., 31470.,
      38319., 40362., 39615., 41730., 44799., 47202., 46095., 48570.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,  3640.,  3700.,  3760.,  6782.,  6908.,  7034.,  7160.,  5164.,
      5272.,  5380.,  5488.,  12510., 12780., 13050., 13320., 19155., 19614.,
      20073., 20532., 12582., 12924., 13266., 13608., 8620.,  8920.,  9220.,
      9520.,  12038., 12524., 13010., 13496., 7132.,  7480.,  7828.,  8176.,
      23980., 24440., 24900., 25360., 34982., 35708., 36434., 37160., 22364.,
      22872., 23380., 23888., 35910., 36780., 37650., 38520., 50655., 52014.,
      53373., 54732., 31182., 32124., 33066., 34008., 19420., 20120., 20820.,
      21520., 25838., 26924., 28010., 29096., 14732., 15480., 16228., 16976.,
      44380., 45240., 46100., 46960., 63182., 64508., 65834., 67160., 39564.,
      40472., 41380., 42288., 59310., 60780., 62250., 63720., 82155., 84414.,
      86673., 88932., 49782., 51324., 52866., 54408., 30220., 31320., 32420.,
      33520., 39638., 41324., 43010., 44696., 22332., 23480., 24628., 25776.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 14115., 14430., 14745., 15060.,
      24195., 24798., 25401., 26004., 26715., 27390., 28065., 28740.,
      43095., 44238., 45381., 46524., 45615., 46830., 48045., 49260.,
      55695., 57198., 58701., 60204., 58215., 59790., 61365., 62940.,
      74595., 76638., 78681., 80724., 77115., 79230., 81345., 83460.,
      87195., 89598., 92001., 94404., 89715., 92190., 94665., 97140.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7192.,   13780.,  10584.,  25860., 39822., 26340.,  18328.,
      25876.,  15576.,  49592.,  72580., 46584., 75060.,  106422.,
      65940.,  41528.,  55876.,  32376., 91992., 131380., 82584.,
      124260., 173022., 105540., 64728., 85876., 49176.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838.,  29166.,  50478.,  55806.,
                                         90438.,  95766.,  117078., 122406.,
                                         157038., 162366., 183678., 189006.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152.,  14384.,  27068.,  27560.,  20744.,  21168.,  50652.,  51720.,
      77826.,  79644.,  51324.,  52680.,  35464.,  36656.,  49820.,  51752.,
      29768.,  31152.,  97352.,  99184.,  142268., 145160., 91144.,  93168.,
      146652., 150120., 207426., 212844., 128124., 131880., 80264.,  83056.,
      107420., 111752., 61768.,  64752.,  180552., 183984., 257468., 262760.,
      161544., 165168., 242652., 248520., 337026., 346044., 204924., 211080.,
      125064., 129456., 165020., 171752., 93768.,  98352.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722.,  47676.,  57090.,  58332.,  98562.,  100956., 108930., 111612.,
      176322., 180876., 186690., 191532., 228162., 234156., 238530., 244812.,
      305922., 314076., 316290., 324732., 357762., 367356., 368130., 378012.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  53644.,  54136.,  54628.,  55120.,
      41064.,  41488.,  41912.,  42336.,  100236., 101304., 102372., 103440.,
      153834., 155652., 157470., 159288., 101292., 102648., 104004., 105360.,
      69736.,  70928.,  72120.,  73312.,  97708.,  99640.,  101572., 103504.,
      58152.,  59536.,  60920.,  62304.,  192872., 194704., 196536., 198368.,
      281644., 284536., 287428., 290320., 180264., 182288., 184312., 186336.,
      289836., 293304., 296772., 300240., 409434., 414852., 420270., 425688.,
      252492., 256248., 260004., 263760., 157736., 160528., 163320., 166112.,
      210508., 214840., 219172., 223504., 120552., 123536., 126520., 129504.,
      357672., 361104., 364536., 367968., 509644., 514936., 520228., 525520.,
      319464., 323088., 326712., 330336., 479436., 485304., 491172., 497040.,
      665034., 674052., 683070., 692088., 403692., 409848., 416004., 422160.,
      245736., 250128., 254520., 258912., 323308., 330040., 336772., 343504.,
      182952., 187536., 192120., 196704.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  112938., 114180., 115422., 116664.,
      194730., 197124., 199518., 201912., 215178., 217860., 220542., 223224.,
      348090., 352644., 357198., 361752., 368538., 373380., 378222., 383064.,
      450330., 456324., 462318., 468312., 470778., 477060., 483342., 489624.,
      603690., 611844., 619998., 628152., 624138., 632580., 641022., 649464.,
      705930., 715524., 725118., 734712., 726378., 736260., 746142., 756024.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      226.,  304.,  223.,  744.,  834.,  546.,  514.,  556.,  337.,
      1396., 1474., 943.,  2094., 2184., 1356., 1144., 1186., 697.,
      2566., 2644., 1663., 3444., 3534., 2166., 1774., 1816., 1057.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564.,  1014., 1104.,
                                         1824., 1914., 2364., 2454.,
                                         3174., 3264., 3714., 3804.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      422.,  452.,  566.,  608.,  412.,  446.,  1362., 1488., 1524.,
      1668., 987.,  1092., 890.,  1028., 962.,  1112., 568.,  674.,
      2582., 2792., 2726., 2948., 1732., 1886., 3792., 4188., 3954.,
      4368., 2427., 2712., 1970., 2288., 2042., 2372., 1168., 1394.,
      4742., 5132., 4886., 5288., 3052., 3326., 6222., 6888., 6384.,
      7068., 3867., 4332., 3050., 3548., 3122., 3632., 1768., 2114.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 1848., 2028., 2010., 2208.,
      3306., 3648., 3468., 3828., 4278., 4728., 4440., 4908.,
      5736., 6348., 5898., 6528., 6708., 7428., 6870., 7608.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      814.,   844.,   874.,  904.,   1090.,  1132.,  1174.,  1216.,  790.,
      824.,   858.,   892.,  2598.,  2724.,  2850.,  2976.,  2904.,  3048.,
      3192.,  3336.,  1869., 1974.,  2079.,  2184.,  1642.,  1780.,  1918.,
      2056.,  1774.,  1924., 2074.,  2224.,  1030.,  1136.,  1242.,  1348.,
      4954.,  5164.,  5374., 5584.,  5230.,  5452.,  5674.,  5896.,  3310.,
      3464.,  3618.,  3772., 7188.,  7584.,  7980.,  8376.,  7494.,  7908.,
      8322.,  8736.,  4569., 4854.,  5139.,  5424.,  3622.,  3940.,  4258.,
      4576.,  3754.,  4084., 4414.,  4744.,  2110.,  2336.,  2562.,  2788.,
      9094.,  9484.,  9874., 10264., 9370.,  9772.,  10174., 10576., 5830.,
      6104.,  6378.,  6652., 11778., 12444., 13110., 13776., 12084., 12768.,
      13452., 14136., 7269., 7734.,  8199.,  8664.,  5602.,  6100.,  6598.,
      7096.,  5734.,  6244., 6754.,  7264.,  3190.,  3536.,  3882.,  4228.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,
      3516.,  3696.,  3876.,  4056.,  3822.,  4020.,  4218.,  4416.,
      6270.,  6612.,  6954.,  7296.,  6576.,  6936.,  7296.,  7656.,
      8106.,  8556.,  9006.,  9456.,  8412.,  8880.,  9348.,  9816.,
      10860., 11472., 12084., 12696., 11166., 11796., 12426., 13056.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1676.,  2276.,  1672.,  5619.,  6303.,  4110.,  3800.,  4112.,  2464.,
      10676., 11276., 7192.,  15879., 16563., 10230., 8480.,  8792.,  5104.,
      19676., 20276., 12712., 26139., 26823., 16350., 13160., 13472., 7744.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567.,  4251.,  7671.,  8355.,
                                         13827., 14511., 17931., 18615.,
                                         24087., 24771., 28191., 28875.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3238.,  3352.,  4390.,  4552.,  3212.,  3344.,  10743., 11238., 12039.,
      12606., 7806.,  8220.,  7054.,  7600.,  7630.,  8224.,  4508.,  4928.,
      20518., 21352., 21670., 22552., 13772., 14384., 30183., 31758., 31479.,
      33126., 19326., 20460., 15694., 16960., 16270., 17584., 9308.,  10208.,
      37798., 39352., 38950., 40552., 24332., 25424., 49623., 52278., 50919.,
      53646., 30846., 32700., 24334., 26320., 24910., 26944., 14108., 15488.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  8151.,  8502.,  14631., 15342., 15927., 16710.,
      26295., 27654., 27591., 29022., 34071., 35862., 35367., 37230.,
      45735., 48174., 47031., 49542., 53511., 56382., 54807., 57750.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6362.,  6476.,   6590.,   6704.,   8618.,  8780.,  8942.,   9104.,
      6292.,  6424.,   6556.,   6688.,   20991., 21486., 21981.,  22476.,
      23511., 24078.,  24645.,  25212.,  15198., 15612., 16026.,  16440.,
      13562., 14108.,  14654.,  15200.,  14666., 15260., 15854.,  16448.,
      8596.,  9016.,   9436.,   9856.,   40202., 41036., 41870.,  42704.,
      42458., 43340.,  44222.,  45104.,  26932., 27544., 28156.,  28768.,
      58791., 60366.,  61941.,  63516.,  61311., 62958., 64605.,  66252.,
      37518., 38652.,  39786.,  40920.,  30122., 31388., 32654.,  33920.,
      31226., 32540.,  33854.,  35168.,  17716., 18616., 19516.,  20416.,
      74042., 75596.,  77150.,  78704.,  76298., 77900., 79502.,  81104.,
      47572., 48664.,  49756.,  50848.,  96591., 99246., 101901., 104556.,
      99111., 101838., 104565., 107292., 59838., 61692., 63546.,  65400.,
      46682., 48668.,  50654.,  52640.,  47786., 49820., 51854.,  53888.,
      26836., 28216.,  29596.,  30976.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431.,  13710.,  13989.,  14268.,  15951.,  16302.,  16653.,  17004.,
      28551.,  29262.,  29973.,  30684.,  31071.,  31854.,  32637.,  33420.,
      51231.,  52590.,  53949.,  55308.,  53751.,  55182.,  56613.,  58044.,
      66351.,  68142.,  69933.,  71724.,  68871.,  70734.,  72597.,  74460.,
      89031.,  91470.,  93909.,  96348.,  91551.,  94062.,  96573.,  99084.,
      104151., 107022., 109893., 112764., 106671., 109614., 112557., 115500.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12892.,  17596.,  12936.,  43638.,  48966.,  31860.,  29164.,
      31564.,  18792.,  83452.,  88156.,  56136.,  123558., 128886.,
      79380.,  65164.,  67564.,  38952.,  154012., 158716., 99336.,
      203478., 208806., 126900., 101164., 103564., 59112.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654.,  32982.,  59622.,  64950.,
                                         107574., 112902., 139542., 144870.,
                                         187494., 192822., 219462., 224790.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25340.,  25784.,  34556.,  35192.,  25352.,  25872.,  85314.,  87276.,
      95682.,  97932.,  62076.,  63720.,  56156.,  58328.,  60764.,  63128.,
      35912.,  37584.,  163580., 166904., 172796., 176312., 109832., 112272.,
      240834., 247116., 251202., 257772., 154236., 158760., 125276., 130328.,
      129884., 135128., 74312.,  77904.,  301820., 308024., 311036., 317432.,
      194312., 198672., 396354., 406956., 406722., 417612., 246396., 253800.,
      194396., 202328., 199004., 207128., 112712., 118224.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  64578.,  65964.,  116418., 119244., 126786., 129900.,
      209730., 215148., 220098., 225804., 271938., 279084., 282306., 289740.,
      365250., 374988., 375618., 385644., 427458., 438924., 437826., 449580.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50236.,  50680.,  51124.,  51568.,  68476.,  69112.,  69748.,  70384.,
      50184.,  50704.,  51224.,  51744.,  168666., 170628., 172590., 174552.,
      189114., 191364., 193614., 195864., 122508., 124152., 125796., 127440.,
      110140., 112312., 114484., 116656., 119164., 121528., 123892., 126256.,
      70152.,  71824.,  73496.,  75168.,  323836., 327160., 330484., 333808.,
      342076., 345592., 349108., 352624., 217224., 219664., 222104., 224544.,
      475386., 481668., 487950., 494232., 495834., 502404., 508974., 515544.,
      303948., 308472., 312996., 317520., 245500., 250552., 255604., 260656.,
      254524., 259768., 265012., 270256., 145032., 148624., 152216., 155808.,
      597436., 603640., 609844., 616048., 615676., 622072., 628468., 634864.,
      384264., 388624., 392984., 397344., 782106., 792708., 803310., 813912.,
      802554., 813444., 824334., 835224., 485388., 492792., 500196., 507600.,
      380860., 388792., 396724., 404656., 389884., 398008., 406132., 414256.,
      219912., 225424., 230936., 236448.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 127770., 129156., 130542., 131928.,
      230010., 232836., 235662., 238488., 250458., 253572., 256686., 259800.,
      414042., 419460., 424878., 430296., 434490., 440196., 445902., 451608.,
      536730., 543876., 551022., 558168., 557178., 564612., 572046., 579480.,
      720762., 730500., 740238., 749976., 741210., 751236., 761262., 771288.,
      843450., 854916., 866382., 877848., 863898., 875652., 887406., 899160.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      274.,  352.,  430.,  301.,  960.,  1050., 1140., 732.,  670.,
      712.,  754.,  451.,  1834., 1912., 1990., 1261., 2760., 2850.,
      2940., 1812., 1510., 1552., 1594., 931.,  3394., 3472., 3550.,
      2221., 4560., 4650., 4740., 2892., 2350., 2392., 2434., 1411.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  1320., 1410., 1500., 2400., 2490., 2580.,
      3120., 3210., 3300., 4200., 4290., 4380., 4920., 5010., 5100.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      512.,  548.,  656.,  704.,  800.,  860.,  556.,  602.,  1758.,
      1920., 1920., 2100., 2082., 2280., 1323., 1464., 1160., 1340.,
      1232., 1424., 1304., 1508., 760.,  902.,  3392., 3668., 3536.,
      3824., 3680., 3980., 2316., 2522., 4998., 5520., 5160., 5700.,
      5322., 5880., 3243., 3624., 2600., 3020., 2672., 3104., 2744.,
      3188., 1560., 1862., 6272., 6788., 6416., 6944., 6560., 7100.,
      4076., 4442., 8238., 9120., 8400., 9300., 8562., 9480., 5163.,
      5784., 4040., 4700., 4112., 4784., 4184., 4868., 2360., 2822.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272., 1380., 1434., 1560., 2406.,  2640., 2568.,
      2820., 2730., 3000., 4350., 4800., 4512., 4980.,  4674., 5160.,
      5646., 6240., 5808., 6420., 5970., 6600., 7590.,  8400., 7752.,
      8580., 7914., 8760., 8886., 9840., 9048., 10020., 9210., 10200.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      988.,   1024.,  1060.,  1096.,  1264.,  1312.,  1360.,  1408.,  1540.,
      1600.,  1660.,  1720.,  1066.,  1112.,  1158.,  1204.,  3354.,  3516.,
      3678.,  3840.,  3660.,  3840.,  4020.,  4200.,  3966.,  4164.,  4362.,
      4560.,  2505.,  2646.,  2787.,  2928.,  2140.,  2320.,  2500.,  2680.,
      2272.,  2464.,  2656.,  2848.,  2404.,  2608.,  2812.,  3016.,  1378.,
      1520.,  1662.,  1804.,  6508.,  6784.,  7060.,  7336.,  6784.,  7072.,
      7360.,  7648.,  7060.,  7360.,  7660.,  7960.,  4426.,  4632.,  4838.,
      5044.,  9474.,  9996.,  10518., 11040., 9780.,  10320., 10860., 11400.,
      10086., 10644., 11202., 11760., 6105.,  6486.,  6867.,  7248.,  4780.,
      5200.,  5620.,  6040.,  4912.,  5344.,  5776.,  6208.,  5044.,  5488.,
      5932.,  6376.,  2818.,  3120.,  3422.,  3724.,  12028., 12544., 13060.,
      13576., 12304., 12832., 13360., 13888., 12580., 13120., 13660., 14200.,
      7786.,  8152.,  8518.,  8884.,  15594., 16476., 17358., 18240., 15900.,
      16800., 17700., 18600., 16206., 17124., 18042., 18960., 9705.,  10326.,
      10947., 11568., 7420.,  8080.,  8740.,  9400.,  7552.,  8224.,  8896.,
      9568.,  7684.,  8368.,  9052.,  9736.,  4258.,  4720.,  5182.,  5644.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  4578.,  4812.,  5046.,  5280.,  4884.,  5136.,
      5388.,  5640.,  5190.,  5460.,  5730.,  6000.,  8250.,  8700.,  9150.,
      9600.,  8556.,  9024.,  9492.,  9960.,  8862.,  9348.,  9834.,  10320.,
      10698., 11292., 11886., 12480., 11004., 11616., 12228., 12840., 11310.,
      11940., 12570., 13200., 14370., 15180., 15990., 16800., 14676., 15504.,
      16332., 17160., 14982., 15828., 16674., 17520., 16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2048.,  2648.,  3248.,  2272.,  7275.,  7959.,  8643.,  5526.,  4964.,
      5276.,  5588.,  3304.,  14048., 14648., 15248., 9632.,  20955., 21639.,
      22323., 13686., 11204., 11516., 11828., 6824.,  26048., 26648., 27248.,
      16992., 34635., 35319., 36003., 21846., 17444., 17756., 18068., 10344.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4539.,  5223.,  5907.,  10011., 10695., 11379., 18219., 18903., 19587.,
      23691., 24375., 25059., 31899., 32583., 33267., 37371., 38055., 38739.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3958.,  4096.,  5110.,  5296.,  6262.,  6496.,  4364.,  4544.,  13911.,
      14550., 15207., 15918., 16503., 17286., 10494., 11052., 9214.,  9928.,
      9790.,  10552., 10366., 11176., 6044.,  6608.,  26998., 28096., 28150.,
      29296., 29302., 30496., 18444., 19264., 39831., 41910., 41127., 43278.,
      42423., 44646., 25854., 27372., 20734., 22408., 21310., 23032., 21886.,
      23656., 12444., 13648., 50038., 52096., 51190., 53296., 52342., 54496.,
      32524., 33984., 65751., 69270., 67047., 70638., 68343., 72006., 41214.,
      43692., 32254., 34888., 32830., 35512., 33406., 36136., 18844., 20688.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,  9078.,  10023., 10446., 11319., 11814., 19095., 20022., 20391.,
      21390., 21687., 22758., 34647., 36438., 35943., 37806., 37239., 39174.,
      45015., 47382., 46311., 48750., 47607., 50118., 60567., 63798., 61863.,
      65166., 63159., 66534., 70935., 74742., 72231., 76110., 73527., 77478.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7778.,   7916.,   8054.,   8192.,   10034.,  10220.,  10406.,  10592.,
      12290.,  12524.,  12758.,  12992.,  8548.,   8728.,   8908.,   9088.,
      27183.,  27822.,  28461.,  29100.,  29703.,  30414.,  31125.,  31836.,
      32223.,  33006.,  33789.,  34572.,  20430.,  20988.,  21546.,  22104.,
      17714.,  18428.,  19142.,  19856.,  18818.,  19580.,  20342.,  21104.,
      19922.,  20732.,  21542.,  22352.,  11524.,  12088.,  12652.,  13216.,
      52898.,  53996.,  55094.,  56192.,  55154.,  56300.,  57446.,  58592.,
      57410.,  58604.,  59798.,  60992.,  36068.,  36888.,  37708.,  38528.,
      77583.,  79662.,  81741.,  83820.,  80103.,  82254.,  84405.,  86556.,
      82623.,  84846.,  87069.,  89292.,  50190.,  51708.,  53226.,  54744.,
      39794.,  41468.,  43142.,  44816.,  40898.,  42620.,  44342.,  46064.,
      42002.,  43772.,  45542.,  47312.,  23684.,  24888.,  26092.,  27296.,
      98018.,  100076., 102134., 104192., 100274., 102380., 104486., 106592.,
      102530., 104684., 106838., 108992., 63588.,  65048.,  66508.,  67968.,
      127983., 131502., 135021., 138540., 130503., 134094., 137685., 141276.,
      133023., 136686., 140349., 144012., 79950.,  82428.,  84906.,  87384.,
      61874.,  64508.,  67142.,  69776.,  62978.,  65660.,  68342.,  71024.,
      64082.,  66812.,  69542.,  72272.,  35844.,  37688.,  39532.,  41376.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103.,  17454.,  17805.,  18156.,  19623.,  20046.,  20469.,  20892.,
      22143.,  22638.,  23133.,  23628.,  37263.,  38190.,  39117.,  40044.,
      39783.,  40782.,  41781.,  42780.,  42303.,  43374.,  44445.,  45516.,
      67503.,  69294.,  71085.,  72876.,  70023.,  71886.,  73749.,  75612.,
      72543.,  74478.,  76413.,  78348.,  87663.,  90030.,  92397.,  94764.,
      90183.,  92622.,  95061.,  97500.,  92703.,  95214.,  97725.,  100236.,
      117903., 121134., 124365., 127596., 120423., 123726., 127029., 130332.,
      122943., 126318., 129693., 133068., 138063., 141870., 145677., 149484.,
      140583., 144462., 148341., 152220., 143103., 147054., 151005., 154956.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15820.,  20524.,  25228.,  17640.,  56598.,  61926.,  67254.,  42900.,
      38140.,  40540.,  42940.,  25224.,  109900., 114604., 119308., 75240.,
      163158., 168486., 173814., 106260., 86140.,  88540.,  90940.,  52104.,
      203980., 208684., 213388., 132840., 269718., 275046., 280374., 169620.,
      134140., 136540., 138940., 78984.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35286.,  40614.,  45942.,  77910.,  83238.,  88566.,
      141846., 147174., 152502., 184470., 189798., 195126.,
      248406., 253734., 259062., 291030., 296358., 301686.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31100.,  31640.,  40316.,  41048.,  49532.,  50456.,  34568.,  35280.,
      110658., 113196., 121026., 123852., 131394., 134508., 83580.,  85800.,
      73436.,  76280.,  78044.,  81080.,  82652.,  85880.,  48200.,  50448.,
      215420., 219800., 224636., 229208., 233852., 238616., 147208., 150480.,
      318018., 326316., 328386., 336972., 338754., 347628., 206460., 212520.,
      165596., 172280., 170204., 177080., 174812., 181880., 99400.,  104208.,
      399740., 407960., 408956., 417368., 418172., 426776., 259848., 265680.,
      525378., 539436., 535746., 550092., 546114., 560748., 329340., 339240.,
      257756., 268280., 262364., 273080., 266972., 277880., 150600., 157968.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,  152130., 155820.,
      162498., 166476., 172866., 177132., 276546., 283692., 286914., 294348.,
      297282., 305004., 359490., 368940., 369858., 379596., 380226., 390252.,
      483906., 496812., 494274., 507468., 504642., 518124., 566850., 582060.,
      577218., 592716., 587586., 603372.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61660.,   62200.,   62740.,   63280.,   79900.,   80632.,   81364.,
      82096.,   98140.,   99064.,   99988.,   100912.,  68424.,   69136.,
      69848.,   70560.,   218778.,  221316.,  223854.,  226392.,  239226.,
      242052.,  244878.,  247704.,  259674.,  262788.,  265902.,  269016.,
      164940.,  167160.,  169380.,  171600.,  144028.,  146872.,  149716.,
      152560.,  153052.,  156088.,  159124.,  162160.,  162076.,  165304.,
      168532.,  171760.,  94152.,   96400.,   98648.,   100896.,  426460.,
      430840.,  435220.,  439600.,  444700.,  449272.,  453844.,  458416.,
      462940.,  467704.,  472468.,  477232.,  291144.,  294416.,  297688.,
      300960.,  627738.,  636036.,  644334.,  652632.,  648186.,  656772.,
      665358.,  673944.,  668634.,  677508.,  686382.,  695256.,  406860.,
      412920.,  418980.,  425040.,  324508.,  331192.,  337876.,  344560.,
      333532.,  340408.,  347284.,  354160.,  342556.,  349624.,  356692.,
      363760.,  193992.,  198800.,  203608.,  208416.,  791260.,  799480.,
      807700.,  815920.,  809500.,  817912.,  826324.,  834736.,  827740.,
      836344.,  844948.,  853552.,  513864.,  519696.,  525528.,  531360.,
      1036698., 1050756., 1064814., 1078872., 1057146., 1071492., 1085838.,
      1100184., 1077594., 1092228., 1106862., 1121496., 648780.,  658680.,
      668580.,  678480.,  504988.,  515512.,  526036.,  536560.,  514012.,
      524728.,  535444.,  546160.,  523036.,  533944.,  544852.,  555760.,
      293832.,  301200.,  308568.,  315936.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986.,  138372.,  139758.,  141144.,  157434.,  159108.,  160782.,
      162456.,  177882.,  179844.,  181806.,  183768.,  300570.,  304260.,
      307950.,  311640.,  321018.,  324996.,  328974.,  332952.,  341466.,
      345732.,  349998.,  354264.,  545946.,  553092.,  560238.,  567384.,
      566394.,  573828.,  581262.,  588696.,  586842.,  594564.,  602286.,
      610008.,  709530.,  718980.,  728430.,  737880.,  729978.,  739716.,
      749454.,  759192.,  750426.,  760452.,  770478.,  780504.,  954906.,
      967812.,  980718.,  993624.,  975354.,  988548.,  1001742., 1014936.,
      995802.,  1009284., 1022766., 1036248., 1118490., 1133700., 1148910.,
      1164120., 1138938., 1154436., 1169934., 1185432., 1159386., 1175172.,
      1190958., 1206744.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      276.,  456.,  318.,  606.,  906.,  588.,  400.,  562.,  340.,
      1266., 1806., 1128., 1596., 2256., 1398., 880.,  1192., 700.,
      2256., 3156., 1938., 2586., 3606., 2208., 1360., 1822., 1060.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411.,  501.,  861.,  951.,
                                         1761., 1851., 2211., 2301.,
                                         3111., 3201., 3561., 3651.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912.,  579.,  636.,  1113., 1212., 1650.,
      1812., 1059., 1176., 704.,  800.,  971.,  1124., 572.,  680.,
      2313., 2532., 3270., 3612., 2019., 2256., 2913., 3192., 4080.,
      4512., 2499., 2796., 1544., 1760., 2051., 2384., 1172., 1400.,
      4113., 4512., 5700., 6312., 3459., 3876., 4713., 5172., 6510.,
      7212., 3939., 4416., 2384., 2720., 3131., 3644., 1772., 2120.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  921.,  1002., 1569., 1722., 1731., 1902.,
      3189., 3522., 3351., 3702., 3999., 4422., 4161., 4602.,
      5619., 6222., 5781., 6402., 6429., 7122., 6591., 7302.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,   1026.,  1065., 1104., 1608.,  1680.,  1752.,  1824.,  1101.,
      1158.,  1215.,  1272., 2127., 2226.,  2325.,  2424.,  3138.,  3300.,
      3462.,  3624.,  2001., 2118., 2235.,  2352.,  1312.,  1408.,  1504.,
      1600.,  1789.,  1942., 2095., 2248.,  1036.,  1144.,  1252.,  1360.,
      4407.,  4626.,  4845., 5064., 6198.,  6540.,  6882.,  7224.,  3801.,
      4038.,  4275.,  4512., 5547., 5826.,  6105.,  6384.,  7728.,  8160.,
      8592.,  9024.,  4701., 4998., 5295.,  5592.,  2872.,  3088.,  3304.,
      3520.,  3769.,  4102., 4435., 4768.,  2116.,  2344.,  2572.,  2800.,
      7827.,  8226.,  8625., 9024., 10788., 11400., 12012., 12624., 6501.,
      6918.,  7335.,  7752., 8967., 9426.,  9885.,  10344., 12318., 13020.,
      13722., 14424., 7401., 7878., 8355.,  8832.,  4432.,  4768.,  5104.,
      5440.,  5749.,  6262., 6775., 7288.,  3196.,  3544.,  3892.,  4240.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1761.,  1842.,  1923.,  2004.,
      2985.,  3138.,  3291.,  3444.,  3291.,  3462.,  3633.,  3804.,
      6045.,  6378.,  6711.,  7044.,  6351.,  6702.,  7053.,  7404.,
      7575.,  7998.,  8421.,  8844.,  7881.,  8322.,  8763.,  9204.,
      10635., 11238., 11841., 12444., 10941., 11562., 12183., 12804.,
      12165., 12858., 13551., 14244., 12471., 13182., 13893., 14604.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2070.,  3423.,  2382.,  4590.,  6843.,  4422.,  2980.,  4154.,  2484.,
      9630.,  13683., 8502.,  12150., 17103., 10542., 6580.,  8834.,  5124.,
      17190., 23943., 14622., 19710., 27363., 16662., 10180., 13514., 7764.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081.,  3765.,  6501.,  7185.,
                                         13341., 14025., 16761., 17445.,
                                         23601., 24285., 27021., 27705.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3990.,  4140.,  6567.,  6846.,  4542.,  4764.,  8790.,  9180.,  13047.,
      13686., 8382.,  8844.,  5580.,  5960.,  7702.,  8308.,  4540.,  4968.,
      18390., 19260., 26007., 27366., 16062., 17004., 23190., 24300., 32487.,
      34206., 19902., 21084., 12300., 13160., 16342., 17668., 9340.,  10248.,
      32790., 34380., 45447., 47886., 27582., 29244., 37590., 39420., 51927.,
      54726., 31422., 33324., 19020., 20360., 24982., 27028., 14140., 15528.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  7215.,  7530.,  12399., 13002., 13695., 14370.,
      25359., 26682., 26655., 28050., 31839., 33522., 33135., 34890.,
      44799., 47202., 46095., 48570., 51279., 54042., 52575., 55410.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7830.,   7980.,   8130.,   8280.,   12855., 13134., 13413., 13692.,
      8862.,   9084.,   9306.,   9528.,   17190., 17580., 17970., 18360.,
      25455.,  26094.,  26733.,  27372.,  16302., 16764., 17226., 17688.,
      10780.,  11160.,  11540.,  11920.,  14798., 15404., 16010., 16616.,
      8652.,   9080.,   9508.,   9936.,   35910., 36780., 37650., 38520.,
      50655.,  52014.,  53373.,  54732.,  31182., 32124., 33066., 34008.,
      45270.,  46380.,  47490.,  48600.,  63255., 64974., 66693., 68412.,
      38622.,  39804.,  40986.,  42168.,  23740., 24600., 25460., 26320.,
      31358.,  32684.,  34010.,  35336.,  17772., 18680., 19588., 20496.,
      63990.,  65580.,  67170.,  68760.,  88455., 90894., 93333., 95772.,
      53502.,  55164.,  56826.,  58488.,  73350., 75180., 77010., 78840.,
      101055., 103854., 106653., 109452., 60942., 62844., 64746., 66648.,
      36700.,  38040.,  39380.,  40720.,  47918., 49964., 52010., 54056.,
      26892.,  28280.,  29668.,  31056.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838.,  12081.,  12324.,  14115.,  14430.,  14745.,  15060.,
      24195., 24798.,  25401.,  26004.,  26715.,  27390.,  28065.,  28740.,
      49395., 50718.,  52041.,  53364.,  51915.,  53310.,  54705.,  56100.,
      61995., 63678.,  65361.,  67044.,  64515.,  66270.,  68025.,  69780.,
      87195., 89598.,  92001.,  94404.,  89715.,  92190.,  94665.,  97140.,
      99795., 102558., 105321., 108084., 102315., 105150., 107985., 110820.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16020.,  26502.,  18420.,  35700.,  53142.,  34260.,  22968.,
      31876.,  18936.,  75060.,  106422., 65940.,  94740.,  133062.,
      81780.,  50808.,  67876.,  39096.,  134100., 186342., 113460.,
      153780., 212982., 129300., 78648.,  103876., 59256.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838.,  29166.,  50478.,  55806.,
                                         103758., 109086., 130398., 135726.,
                                         183678., 189006., 210318., 215646.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31452.,  32040.,  51906.,  53004.,  35964.,  36840.,  69852.,  71400.,
      103746., 106284., 66684.,  68520.,  44424.,  45936.,  61340.,  63752.,
      36168.,  37872.,  146652., 150120., 207426., 212844., 128124., 131880.,
      185052., 189480., 259266., 266124., 158844., 163560., 98184.,  101616.,
      130460., 135752., 74568.,  78192.,  261852., 268200., 362946., 372684.,
      220284., 226920., 300252., 307560., 414786., 425964., 251004., 258600.,
      151944., 157296., 199580., 207752., 112968., 118512.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722.,  47676.,  57090.,  58332.,  98562.,  100956., 108930., 111612.,
      202242., 207516., 212610., 218172., 254082., 260796., 264450., 271452.,
      357762., 367356., 368130., 378012., 409602., 420636., 419970., 431292.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62316.,  62904.,  63492.,  64080.,  102714., 103812., 104910., 106008.,
      71052.,  71928.,  72804.,  73680.,  138156., 139704., 141252., 142800.,
      204954., 207492., 210030., 212568., 131532., 133368., 135204., 137040.,
      87336.,  88848.,  90360.,  91872.,  120268., 122680., 125092., 127504.,
      70632.,  72336.,  74040.,  75744.,  289836., 293304., 296772., 300240.,
      409434., 414852., 420270., 425688., 252492., 256248., 260004., 263760.,
      365676., 370104., 374532., 378960., 511674., 518532., 525390., 532248.,
      312972., 317688., 322404., 327120., 192936., 196368., 199800., 203232.,
      255628., 260920., 266212., 271504., 145512., 149136., 152760., 156384.,
      517356., 523704., 530052., 536400., 716154., 725892., 735630., 745368.,
      433932., 440568., 447204., 453840., 593196., 600504., 607812., 615120.,
      818394., 829572., 840750., 851928., 494412., 502008., 509604., 517200.,
      298536., 303888., 309240., 314592., 390988., 399160., 407332., 415504.,
      220392., 225936., 231480., 237024.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  112938., 114180., 115422., 116664.,
      194730., 197124., 199518., 201912., 215178., 217860., 220542., 223224.,
      399210., 404484., 409758., 415032., 419658., 425220., 430782., 436344.,
      501450., 508164., 514878., 521592., 521898., 528900., 535902., 542904.,
      705930., 715524., 725118., 734712., 726378., 736260., 746142., 756024.,
      808170., 819204., 830238., 841272., 828618., 839940., 851262., 862584.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  564.,  384.,  1014., 1104., 708.,  640.,  682.,  409.,
      2094., 2184., 1356., 2634., 2724., 1680., 1396., 1438., 841.,
      3714., 3804., 2328., 4254., 4344., 2652., 2152., 2194., 1273.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  564.,  1014., 1104.,
                                         2094., 2184., 2634., 2724.,
                                         3714., 3804., 4254., 4344.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 699.,  768.,  1848., 2028., 2010.,
      2208., 1275., 1416., 1106., 1280., 1178., 1364., 688.,  818.,
      3792., 4188., 3954., 4368., 2427., 2712., 4764., 5268., 4926.,
      5448., 3003., 3360., 2402., 2792., 2474., 2876., 1408., 1682.,
      6708., 7428., 6870., 7608., 4155., 4656., 7680., 8508., 7842.,
      8688., 4731., 5304., 3698., 4304., 3770., 4388., 2128., 2546.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038., 1128., 1848., 2028., 2010., 2208.,
      3792., 4188., 3954., 4368., 4764., 5268., 4926., 5448.,
      6708., 7428., 6870., 7608., 7680., 8508., 7842., 8688.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,  1329.,
      1398.,  1467.,  1536.,  3516.,  3696.,  3876.,  4056.,  3822.,  4020.,
      4218.,  4416.,  2409.,  2550.,  2691.,  2832.,  2038.,  2212.,  2386.,
      2560.,  2170.,  2356.,  2542.,  2728.,  1246.,  1376.,  1506.,  1636.,
      7188.,  7584.,  7980.,  8376.,  7494.,  7908.,  8322.,  8736.,  4569.,
      4854.,  5139.,  5424.,  9024.,  9528.,  10032., 10536., 9330.,  9852.,
      10374., 10896., 5649.,  6006.,  6363.,  6720.,  4414.,  4804.,  5194.,
      5584.,  4546.,  4948.,  5350.,  5752.,  2542.,  2816.,  3090.,  3364.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216., 7809.,
      8310.,  8811.,  9312.,  14532., 15360., 16188., 17016., 14838., 15684.,
      16530., 17376., 8889.,  9462.,  10035., 10608., 6790.,  7396.,  8002.,
      8608.,  6922.,  7540.,  8158.,  8776.,  3838.,  4256.,  4674.,  5092.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,
      3516.,  3696.,  3876.,  4056.,  3822.,  4020.,  4218.,  4416.,
      7188.,  7584.,  7980.,  8376.,  7494.,  7908.,  8322.,  8736.,
      9024.,  9528.,  10032., 10536., 9330.,  9852.,  10374., 10896.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216.,
      14532., 15360., 16188., 17016., 14838., 15684., 16530., 17376.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3567.,  4251.,  2886.,  7671.,  8355.,  5334.,  4736.,  5048.,  2992.,
      15879., 16563., 10230., 19983., 20667., 12678., 10352., 10664., 6160.,
      28191., 28875., 17574., 32295., 32979., 20022., 15968., 16280., 9328.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567.,  4251.,  7671.,  8355.,
                                         15879., 16563., 19983., 20667.,
                                         28191., 28875., 32295., 32979.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  8151.,  8502.,  5502.,  5772.,  14631., 15342., 15927.,
      16710., 10110., 10668., 8782.,  9472.,  9358.,  10096., 5468.,  5984.,
      30183., 31758., 31479., 33126., 19326., 20460., 37959., 39966., 39255.,
      41334., 23934., 25356., 19150., 20704., 19726., 21328., 11228., 12320.,
      53511., 56382., 54807., 57750., 33150., 35148., 61287., 64590., 62583.,
      65958., 37758., 40044., 29518., 31936., 30094., 32560., 16988., 18656.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  8151.,  8502.,  14631., 15342., 15927., 16710.,
      30183., 31758., 31479., 33126., 37959., 39966., 39255., 41334.,
      53511., 56382., 54807., 57750., 61287., 64590., 62583., 65958.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431.,  13710.,  13989.,  14268.,  15951.,  16302.,  16653.,  17004.,
      10734.,  11004.,  11274.,  11544.,  28551.,  29262.,  29973.,  30684.,
      31071.,  31854.,  32637.,  33420.,  19662.,  20220.,  20778.,  21336.,
      16874.,  17564.,  18254.,  18944.,  17978.,  18716.,  19454.,  20192.,
      10420.,  10936.,  11452.,  11968.,  58791.,  60366.,  61941.,  63516.,
      61311.,  62958.,  64605.,  66252.,  37518.,  38652.,  39786.,  40920.,
      73911.,  75918.,  77925.,  79932.,  76431.,  78510.,  80589.,  82668.,
      46446.,  47868.,  49290.,  50712.,  36746.,  38300.,  39854.,  41408.,
      37850.,  39452.,  41054.,  42656.,  21364.,  22456.,  23548.,  24640.,
      104151., 107022., 109893., 112764., 106671., 109614., 112557., 115500.,
      64302.,  66300.,  68298.,  70296.,  119271., 122574., 125877., 129180.,
      121791., 125166., 128541., 131916., 73230.,  75516.,  77802.,  80088.,
      56618.,  59036.,  61454.,  63872.,  57722.,  60188.,  62654.,  65120.,
      32308.,  33976.,  35644.,  37312.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431.,  13710.,  13989.,  14268.,  15951.,  16302.,  16653.,  17004.,
      28551.,  29262.,  29973.,  30684.,  31071.,  31854.,  32637.,  33420.,
      58791.,  60366.,  61941.,  63516.,  61311.,  62958.,  64605.,  66252.,
      73911.,  75918.,  77925.,  79932.,  76431.,  78510.,  80589.,  82668.,
      104151., 107022., 109893., 112764., 106671., 109614., 112557., 115500.,
      119271., 122574., 125877., 129180., 121791., 125166., 128541., 131916.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27654.,  32982.,  22356.,  59622.,  64950.,  41364.,  36364.,
      38764.,  22824.,  123558., 128886., 79380.,  155526., 160854.,
      98388.,  79564.,  81964.,  47016.,  219462., 224790., 136404.,
      251430., 256758., 155412., 122764., 125164., 71208.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654.,  32982.,  59622.,  64950.,
                                         123558., 128886., 155526., 160854.,
                                         219462., 224790., 251430., 256758.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  64578.,  65964.,  43644.,  44712.,  116418., 119244.,
      126786., 129900., 80508.,  82728.,  69980.,  72728.,  74588.,  77528.,
      43592.,  45648.,  240834., 247116., 251202., 257772., 154236., 158760.,
      303042., 311052., 313410., 321708., 191100., 196776., 152924., 159128.,
      157532., 163928., 89672.,  94032.,  427458., 438924., 437826., 449580.,
      264828., 272808., 489666., 502860., 500034., 513516., 301692., 310824.,
      235868., 245528., 240476., 250328., 135752., 142416.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  64578.,  65964.,  116418., 119244., 126786., 129900.,
      240834., 247116., 251202., 257772., 303042., 311052., 313410., 321708.,
      427458., 438924., 437826., 449580., 489666., 502860., 500034., 513516.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322.,  108420., 109518., 110616.,  127770., 129156.,  130542.,
      131928.,  86220.,  87288.,  88356.,   89424.,  230010.,  232836.,
      235662.,  238488., 250458., 253572.,  256686., 259800.,  158796.,
      161016.,  163236., 165456., 137212.,  139960., 142708.,  145456.,
      146236.,  149176., 152116., 155056.,  85128.,  87184.,   89240.,
      91296.,   475386., 481668., 487950.,  494232., 495834.,  502404.,
      508974.,  515544., 303948., 308472.,  312996., 317520.,  598074.,
      606084.,  614094., 622104., 618522.,  626820., 635118.,  643416.,
      376524.,  382200., 387876., 393552.,  299644., 305848.,  312052.,
      318256.,  308668., 315064., 321460.,  327856., 174984.,  179344.,
      183704.,  188064., 843450., 854916.,  866382., 877848.,  863898.,
      875652.,  887406., 899160., 521676.,  529656., 537636.,  545616.,
      966138.,  979332., 992526., 1005720., 986586., 1000068., 1013550.,
      1027032., 594252., 603384., 612516.,  621648., 462076.,  471736.,
      481396.,  491056., 471100., 480952.,  490804., 500656.,  264840.,
      271504.,  278168., 284832.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420.,  109518., 110616.,  127770.,  129156., 130542.,
      131928., 230010.,  232836., 235662.,  238488.,  250458., 253572.,
      256686., 259800.,  475386., 481668.,  487950.,  494232., 495834.,
      502404., 508974.,  515544., 598074.,  606084.,  614094., 622104.,
      618522., 626820.,  635118., 643416.,  843450.,  854916., 866382.,
      877848., 863898.,  875652., 887406.,  899160.,  966138., 979332.,
      992526., 1005720., 986586., 1000068., 1013550., 1027032.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  516.,  1320., 1410., 1500., 948.,  838.,
      880.,  922.,  547.,  2760., 2850., 2940., 1812., 3480., 3570.,
      3660., 2244., 1846., 1888., 1930., 1123., 4920., 5010., 5100.,
      3108., 5640., 5730., 5820., 3540., 2854., 2896., 2938., 1699.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  1320., 1410., 1500., 2760., 2850., 2940.,
      3480., 3570., 3660., 4920., 5010., 5100., 5640., 5730., 5820.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110., 1200., 1272.,  1380.,  1434.,  1560.,  939.,   1032.,  2406.,
      2640., 2568., 2820.,  2730.,  3000.,  1707.,  1896.,  1448.,  1676.,
      1520., 1760., 1592.,  1844.,  920.,   1094.,  4998.,  5520.,  5160.,
      5700., 5322., 5880.,  3243.,  3624.,  6294.,  6960.,  6456.,  7140.,
      6618., 7320., 4011.,  4488.,  3176.,  3692.,  3248.,  3776.,  3320.,
      3860., 1880., 2246.,  8886.,  9840.,  9048.,  10020., 9210.,  10200.,
      5547., 6216., 10182., 11280., 10344., 11460., 10506., 11640., 6315.,
      7080., 4904., 5708.,  4976.,  5792.,  5048.,  5876.,  2840.,  3398.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110.,  1200., 1272.,  1380.,  1434.,  1560.,  2406.,  2640.,  2568.,
      2820.,  2730., 3000.,  4998.,  5520.,  5160.,  5700.,  5322.,  5880.,
      6294.,  6960., 6456.,  7140.,  6618.,  7320.,  8886.,  9840.,  9048.,
      10020., 9210., 10200., 10182., 11280., 10344., 11460., 10506., 11640.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  1785.,  1878.,  1971.,  2064.,  4578.,  4812.,
      5046.,  5280.,  4884.,  5136.,  5388.,  5640.,  5190.,  5460.,  5730.,
      6000.,  3225.,  3414.,  3603.,  3792.,  2668.,  2896.,  3124.,  3352.,
      2800.,  3040.,  3280.,  3520.,  2932.,  3184.,  3436.,  3688.,  1666.,
      1840.,  2014.,  2188.,  9474.,  9996.,  10518., 11040., 9780.,  10320.,
      10860., 11400., 10086., 10644., 11202., 11760., 6105.,  6486.,  6867.,
      7248.,  11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280.,
      12534., 13236., 13938., 14640., 7545.,  8022.,  8499.,  8976.,  5836.,
      6352.,  6868.,  7384.,  5968.,  6496.,  7024.,  7552.,  6100.,  6640.,
      7180.,  7720.,  3394.,  3760.,  4126.,  4492.,  16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.,
      10425., 11094., 11763., 12432., 19266., 20364., 21462., 22560., 19572.,
      20688., 21804., 22920., 19878., 21012., 22146., 23280., 11865., 12630.,
      13395., 14160., 9004.,  9808.,  10612., 11416., 9136.,  9952.,  10768.,
      11584., 9268.,  10096., 10924., 11752., 5122.,  5680.,  6238.,  6796.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  4578.,  4812.,  5046.,  5280.,  4884.,  5136.,
      5388.,  5640.,  5190.,  5460.,  5730.,  6000.,  9474.,  9996.,  10518.,
      11040., 9780.,  10320., 10860., 11400., 10086., 10644., 11202., 11760.,
      11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280., 12534.,
      13236., 13938., 14640., 16818., 17772., 18726., 19680., 17124., 18096.,
      19068., 20040., 17430., 18420., 19410., 20400., 19266., 20364., 21462.,
      22560., 19572., 20688., 21804., 22920., 19878., 21012., 22146., 23280.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4539.,  5223.,  5907.,  3894.,  10011., 10695., 11379., 7158.,  6212.,
      6524.,  6836.,  4008.,  20955., 21639., 22323., 13686., 26427., 27111.,
      27795., 16950., 13700., 14012., 14324., 8232.,  37371., 38055., 38739.,
      23478., 42843., 43527., 44211., 26742., 21188., 21500., 21812., 12456.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4539.,  5223.,  5907.,  10011., 10695., 11379., 20955., 21639., 22323.,
      26427., 27111., 27795., 37371., 38055., 38739., 42843., 43527., 44211.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,  9078.,  10023., 10446., 11319., 11814., 7422.,  7788.,  19095.,
      20022., 20391., 21390., 21687., 22758., 13566., 14316., 11518., 12424.,
      12094., 13048., 12670., 13672., 7324.,  8016.,  39831., 41910., 41127.,
      43278., 42423., 44646., 25854., 27372., 50199., 52854., 51495., 54222.,
      52791., 55590., 31998., 33900., 25342., 27400., 25918., 28024., 26494.,
      28648., 15004., 16464., 70935., 74742., 72231., 76110., 73527., 77478.,
      44286., 46956., 81303., 85686., 82599., 87054., 83895., 88422., 50430.,
      53484., 39166., 42376., 39742., 43000., 40318., 43624., 22684., 24912.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,  9078.,  10023., 10446., 11319., 11814., 19095., 20022., 20391.,
      21390., 21687., 22758., 39831., 41910., 41127., 43278., 42423., 44646.,
      50199., 52854., 51495., 54222., 52791., 55590., 70935., 74742., 72231.,
      76110., 73527., 77478., 81303., 85686., 82599., 87054., 83895., 88422.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103.,  17454.,  17805.,  18156.,  19623.,  20046.,  20469.,  20892.,
      22143.,  22638.,  23133.,  23628.,  14478.,  14844.,  15210.,  15576.,
      37263.,  38190.,  39117.,  40044.,  39783.,  40782.,  41781.,  42780.,
      42303.,  43374.,  44445.,  45516.,  26382.,  27132.,  27882.,  28632.,
      22130.,  23036.,  23942.,  24848.,  23234.,  24188.,  25142.,  26096.,
      24338.,  25340.,  26342.,  27344.,  13956.,  14648.,  15340.,  16032.,
      77583.,  79662.,  81741.,  83820.,  80103.,  82254.,  84405.,  86556.,
      82623.,  84846.,  87069.,  89292.,  50190.,  51708.,  53226.,  54744.,
      97743.,  100398., 103053., 105708., 100263., 102990., 105717., 108444.,
      102783., 105582., 108381., 111180., 62094.,  63996.,  65898.,  67800.,
      48626.,  50684.,  52742.,  54800.,  49730.,  51836.,  53942.,  56048.,
      50834.,  52988.,  55142.,  57296.,  28548.,  30008.,  31468.,  32928.,
      138063., 141870., 145677., 149484., 140583., 144462., 148341., 152220.,
      143103., 147054., 151005., 154956., 85902.,  88572.,  91242.,  93912.,
      158223., 162606., 166989., 171372., 160743., 165198., 169653., 174108.,
      163263., 167790., 172317., 176844., 97806.,  100860., 103914., 106968.,
      75122.,  78332.,  81542.,  84752.,  76226.,  79484.,  82742.,  86000.,
      77330.,  80636.,  83942.,  87248.,  43140.,  45368.,  47596.,  49824.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103.,  17454.,  17805.,  18156.,  19623.,  20046.,  20469.,  20892.,
      22143.,  22638.,  23133.,  23628.,  37263.,  38190.,  39117.,  40044.,
      39783.,  40782.,  41781.,  42780.,  42303.,  43374.,  44445.,  45516.,
      77583.,  79662.,  81741.,  83820.,  80103.,  82254.,  84405.,  86556.,
      82623.,  84846.,  87069.,  89292.,  97743.,  100398., 103053., 105708.,
      100263., 102990., 105717., 108444., 102783., 105582., 108381., 111180.,
      138063., 141870., 145677., 149484., 140583., 144462., 148341., 152220.,
      143103., 147054., 151005., 154956., 158223., 162606., 166989., 171372.,
      160743., 165198., 169653., 174108., 163263., 167790., 172317., 176844.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35286.,  40614.,  45942.,  30228.,  77910.,  83238.,  88566.,  55572.,
      47740.,  50140.,  52540.,  30600.,  163158., 168486., 173814., 106260.,
      205782., 211110., 216438., 131604., 105340., 107740., 110140., 62856.,
      291030., 296358., 301686., 182292., 333654., 338982., 344310., 207636.,
      162940., 165340., 167740., 95112.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35286.,  40614.,  45942.,  77910.,  83238.,  88566.,
      163158., 168486., 173814., 205782., 211110., 216438.,
      291030., 296358., 301686., 333654., 338982., 344310.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,  59004.,  60456.,
      152130., 155820., 162498., 166476., 172866., 177132., 108156., 111144.,
      91868.,  95480.,  96476.,  100280., 101084., 105080., 58440.,  61200.,
      318018., 326316., 328386., 336972., 338754., 347628., 206460., 212520.,
      400962., 411564., 411330., 422220., 421698., 432876., 255612., 263208.,
      202460., 210680., 207068., 215480., 211676., 220280., 119880., 125712.,
      566850., 582060., 577218., 592716., 587586., 603372., 353916., 364584.,
      649794., 667308., 660162., 677964., 670530., 688620., 403068., 415272.,
      313052., 325880., 317660., 330680., 322268., 335480., 181320., 190224.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,  152130., 155820.,
      162498., 166476., 172866., 177132., 318018., 326316., 328386., 336972.,
      338754., 347628., 400962., 411564., 411330., 422220., 421698., 432876.,
      566850., 582060., 577218., 592716., 587586., 603372., 649794., 667308.,
      660162., 677964., 670530., 688620.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986.,  138372.,  139758.,  141144.,  157434.,  159108.,  160782.,
      162456.,  177882.,  179844.,  181806.,  183768.,  116556.,  118008.,
      119460.,  120912.,  300570.,  304260.,  307950.,  311640.,  321018.,
      324996.,  328974.,  332952.,  341466.,  345732.,  349998.,  354264.,
      213324.,  216312.,  219300.,  222288.,  180124.,  183736.,  187348.,
      190960.,  189148.,  192952.,  196756.,  200560.,  198172.,  202168.,
      206164.,  210160.,  114120.,  116880.,  119640.,  122400.,  627738.,
      636036.,  644334.,  652632.,  648186.,  656772.,  665358.,  673944.,
      668634.,  677508.,  686382.,  695256.,  406860.,  412920.,  418980.,
      425040.,  791322.,  801924.,  812526.,  823128.,  811770.,  822660.,
      833550.,  844440.,  832218.,  843396.,  854574.,  865752.,  503628.,
      511224.,  518820.,  526416.,  396700.,  404920.,  413140.,  421360.,
      405724.,  414136.,  422548.,  430960.,  414748.,  423352.,  431956.,
      440560.,  233928.,  239760.,  245592.,  251424.,  1118490., 1133700.,
      1148910., 1164120., 1138938., 1154436., 1169934., 1185432., 1159386.,
      1175172., 1190958., 1206744., 697164.,  707832.,  718500.,  729168.,
      1282074., 1299588., 1317102., 1334616., 1302522., 1320324., 1338126.,
      1355928., 1322970., 1341060., 1359150., 1377240., 793932.,  806136.,
      818340.,  830544.,  613276.,  626104.,  638932.,  651760.,  622300.,
      635320.,  648340.,  661360.,  631324.,  644536.,  657748.,  670960.,
      353736.,  362640.,  371544.,  380448.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986.,  138372.,  139758.,  141144.,  157434.,  159108.,  160782.,
      162456.,  177882.,  179844.,  181806.,  183768.,  300570.,  304260.,
      307950.,  311640.,  321018.,  324996.,  328974.,  332952.,  341466.,
      345732.,  349998.,  354264.,  627738.,  636036.,  644334.,  652632.,
      648186.,  656772.,  665358.,  673944.,  668634.,  677508.,  686382.,
      695256.,  791322.,  801924.,  812526.,  823128.,  811770.,  822660.,
      833550.,  844440.,  832218.,  843396.,  854574.,  865752.,  1118490.,
      1133700., 1148910., 1164120., 1138938., 1154436., 1169934., 1185432.,
      1159386., 1175172., 1190958., 1206744., 1282074., 1299588., 1317102.,
      1334616., 1302522., 1320324., 1338126., 1355928., 1322970., 1341060.,
      1359150., 1377240.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      276.,  456.,  318.,  606.,  906.,  588.,  936.,  1356., 858.,
      560.,  772.,  460.,  1596., 2256., 1398., 1926., 2706., 1668.,
      2256., 3156., 1938., 1200., 1612., 940.,  2916., 4056., 2478.,
      3246., 4506., 2748., 3576., 4956., 3018., 1840., 2452., 1420.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      411.,  501.,  861.,  951.,  1311., 1401., 2211., 2301., 2661.,
      2751., 3111., 3201., 4011., 4101., 4461., 4551., 4911., 5001.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      513.,  552.,  840.,  912.,  579.,  636.,  1113., 1212., 1650.,
      1812., 1059., 1176., 1713., 1872., 2460., 2712., 1539., 1716.,
      984.,  1120., 1331., 1544., 772.,  920.,  2913., 3192., 4080.,
      4512., 2499., 2796., 3513., 3852., 4890., 5412., 2979., 3336.,
      4113., 4512., 5700., 6312., 3459., 3876., 2104., 2400., 2771.,
      3224., 1572., 1880., 5313., 5832., 7320., 8112., 4419., 4956.,
      5913., 6492., 8130., 9012., 4899., 5496., 6513., 7152., 8940.,
      9912., 5379., 6036., 3224., 3680., 4211., 4904., 2372., 2840.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  921.,  1002., 1569., 1722., 1731., 1902., 2379.,
      2622., 2541., 2802., 3999., 4422., 4161., 4602., 4809., 5322.,
      4971., 5502., 5619., 6222., 5781., 6402., 7239., 8022., 7401.,
      8202., 8049., 8922., 8211., 9102., 8859., 9822., 9021., 10002.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      987.,   1026.,  1065.,  1104.,  1608.,  1680.,  1752.,  1824.,  1101.,
      1158.,  1215.,  1272.,  2127.,  2226.,  2325.,  2424.,  3138.,  3300.,
      3462.,  3624.,  2001.,  2118.,  2235.,  2352.,  3267.,  3426.,  3585.,
      3744.,  4668.,  4920.,  5172.,  5424.,  2901.,  3078.,  3255.,  3432.,
      1832.,  1968.,  2104.,  2240.,  2449.,  2662.,  2875.,  3088.,  1396.,
      1544.,  1692.,  1840.,  5547.,  5826.,  6105.,  6384.,  7728.,  8160.,
      8592.,  9024.,  4701.,  4998.,  5295.,  5592.,  6687.,  7026.,  7365.,
      7704.,  9258.,  9780.,  10302., 10824., 5601.,  5958.,  6315.,  6672.,
      7827.,  8226.,  8625.,  9024.,  10788., 11400., 12012., 12624., 6501.,
      6918.,  7335.,  7752.,  3912.,  4208.,  4504.,  4800.,  5089.,  5542.,
      5995.,  6448.,  2836.,  3144.,  3452.,  3760.,  10107., 10626., 11145.,
      11664., 13848., 14640., 15432., 16224., 8301.,  8838.,  9375.,  9912.,
      11247., 11826., 12405., 12984., 15378., 16260., 17142., 18024., 9201.,
      9798.,  10395., 10992., 12387., 13026., 13665., 14304., 16908., 17880.,
      18852., 19824., 10101., 10758., 11415., 12072., 5992.,  6448.,  6904.,
      7360.,  7729.,  8422.,  9115.,  9808.,  4276.,  4744.,  5212.,  5680.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1761.,  1842.,  1923.,  2004.,  2985.,
      3138.,  3291.,  3444.,  3291.,  3462.,  3633.,  3804.,  4515.,  4758.,
      5001.,  5244.,  4821.,  5082.,  5343.,  5604.,  7575.,  7998.,  8421.,
      8844.,  7881.,  8322.,  8763.,  9204.,  9105.,  9618.,  10131., 10644.,
      9411.,  9942.,  10473., 11004., 10635., 11238., 11841., 12444., 10941.,
      11562., 12183., 12804., 13695., 14478., 15261., 16044., 14001., 14802.,
      15603., 16404., 15225., 16098., 16971., 17844., 15531., 16422., 17313.,
      18204., 16755., 17718., 18681., 19644., 17061., 18042., 19023., 20004.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2070.,  3423.,  2382.,  4590.,  6843.,  4422.,  7110.,  10263., 6462.,
      4180.,  5714.,  3364.,  12150., 17103., 10542., 14670., 20523., 12582.,
      17190., 23943., 14622., 8980.,  11954., 6884.,  22230., 30783., 18702.,
      24750., 34203., 20742., 27270., 37623., 22782., 13780., 18194., 10404.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3081.,  3765.,  6501.,  7185.,  9921.,  10605., 16761., 17445., 20181.,
      20865., 23601., 24285., 30441., 31125., 33861., 34545., 37281., 37965.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3990.,  4140.,  6567.,  6846.,  4542.,  4764.,  8790.,  9180.,  13047.,
      13686., 8382.,  8844.,  13590., 14220., 19527., 20526., 12222., 12924.,
      7820.,  8360.,  10582., 11428., 6140.,  6728.,  23190., 24300., 32487.,
      34206., 19902., 21084., 27990., 29340., 38967., 41046., 23742., 25164.,
      32790., 34380., 45447., 47886., 27582., 29244., 16780., 17960., 22102.,
      23908., 12540., 13768., 42390., 44460., 58407., 61566., 35262., 37404.,
      47190., 49500., 64887., 68406., 39102., 41484., 51990., 54540., 71367.,
      75246., 42942., 45564., 25740., 27560., 33622., 36388., 18940., 20808.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  7215.,  7530.,  12399., 13002., 13695., 14370., 18879.,
      19842., 20175., 21210., 31839., 33522., 33135., 34890., 38319., 40362.,
      39615., 41730., 44799., 47202., 46095., 48570., 57759., 60882., 59055.,
      62250., 64239., 67722., 65535., 69090., 70719., 74562., 72015., 75930.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7830.,   7980.,   8130.,   8280.,   12855.,  13134.,  13413.,  13692.,
      8862.,   9084.,   9306.,   9528.,   17190.,  17580.,  17970.,  18360.,
      25455.,  26094.,  26733.,  27372.,  16302.,  16764.,  17226.,  17688.,
      26550.,  27180.,  27810.,  28440.,  38055.,  39054.,  40053.,  41052.,
      23742.,  24444.,  25146.,  25848.,  15100.,  15640.,  16180.,  16720.,
      20318.,  21164.,  22010.,  22856.,  11692.,  12280.,  12868.,  13456.,
      45270.,  46380.,  47490.,  48600.,  63255.,  64974.,  66693.,  68412.,
      38622.,  39804.,  40986.,  42168.,  54630.,  55980.,  57330.,  58680.,
      75855.,  77934.,  80013.,  82092.,  46062.,  47484.,  48906.,  50328.,
      63990.,  65580.,  67170.,  68760.,  88455.,  90894.,  93333.,  95772.,
      53502.,  55164.,  56826.,  58488.,  32380.,  33560.,  34740.,  35920.,
      42398.,  44204.,  46010.,  47816.,  23852.,  25080.,  26308.,  27536.,
      82710.,  84780.,  86850.,  88920.,  113655., 116814., 119973., 123132.,
      68382.,  70524.,  72666.,  74808.,  92070.,  94380.,  96690.,  99000.,
      126255., 129774., 133293., 136812., 75822.,  78204.,  80586.,  82968.,
      101430., 103980., 106530., 109080., 138855., 142734., 146613., 150492.,
      83262.,  85884.,  88506.,  91128.,  49660.,  51480.,  53300.,  55120.,
      64478.,  67244.,  70010.,  72776.,  36012.,  37880.,  39748.,  41616.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595.,  11838.,  12081.,  12324.,  14115.,  14430.,  14745.,  15060.,
      24195.,  24798.,  25401.,  26004.,  26715.,  27390.,  28065.,  28740.,
      36795.,  37758.,  38721.,  39684.,  39315.,  40350.,  41385.,  42420.,
      61995.,  63678.,  65361.,  67044.,  64515.,  66270.,  68025.,  69780.,
      74595.,  76638.,  78681.,  80724.,  77115.,  79230.,  81345.,  83460.,
      87195.,  89598.,  92001.,  94404.,  89715.,  92190.,  94665.,  97140.,
      112395., 115518., 118641., 121764., 114915., 118110., 121305., 124500.,
      124995., 128478., 131961., 135444., 127515., 131070., 134625., 138180.,
      137595., 141438., 145281., 149124., 140115., 144030., 147945., 151860.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16020.,  26502.,  18420.,  35700.,  53142.,  34260.,  55380.,  79782.,
      50100.,  32248.,  43876.,  25656.,  94740.,  133062., 81780.,  114420.,
      159702., 97620.,  134100., 186342., 113460., 69368.,  91876.,  52536.,
      173460., 239622., 145140., 193140., 266262., 160980., 212820., 292902.,
      176820., 106488., 139876., 79416.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23838.,  29166.,  50478.,  55806.,  77118.,  82446.,
      130398., 135726., 157038., 162366., 183678., 189006.,
      236958., 242286., 263598., 268926., 290238., 295566.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31452.,  32040.,  51906.,  53004.,  35964.,  36840.,  69852.,  71400.,
      103746., 106284., 66684.,  68520.,  108252., 110760., 155586., 159564.,
      97404.,  100200., 62344.,  64496.,  84380.,  87752.,  48968.,  51312.,
      185052., 189480., 259266., 266124., 158844., 163560., 223452., 228840.,
      311106., 319404., 189564., 195240., 261852., 268200., 362946., 372684.,
      220284., 226920., 134024., 138736., 176540., 183752., 100168., 105072.,
      338652., 346920., 466626., 479244., 281724., 290280., 377052., 386280.,
      518466., 532524., 312444., 321960., 415452., 425640., 570306., 585804.,
      343164., 353640., 205704., 212976., 268700., 279752., 151368., 158832.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722.,  47676.,  57090.,  58332.,  98562.,  100956., 108930., 111612.,
      150402., 154236., 160770., 164892., 254082., 260796., 264450., 271452.,
      305922., 314076., 316290., 324732., 357762., 367356., 368130., 378012.,
      461442., 473916., 471810., 484572., 513282., 527196., 523650., 537852.,
      565122., 580476., 575490., 591132.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62316.,   62904.,   63492.,   64080.,   102714., 103812.,  104910.,
      106008.,  71052.,   71928.,   72804.,   73680.,  138156.,  139704.,
      141252.,  142800.,  204954.,  207492.,  210030., 212568.,  131532.,
      133368.,  135204.,  137040.,  213996.,  216504., 219012.,  221520.,
      307194.,  311172.,  315150.,  319128.,  192012., 194808.,  197604.,
      200400.,  122536.,  124688.,  126840.,  128992., 165388.,  168760.,
      172132.,  175504.,  95592.,   97936.,   100280., 102624.,  365676.,
      370104.,  374532.,  378960.,  511674.,  518532., 525390.,  532248.,
      312972.,  317688.,  322404.,  327120.,  441516., 446904.,  452292.,
      457680.,  613914.,  622212.,  630510.,  638808., 373452.,  379128.,
      384804.,  390480.,  517356.,  523704.,  530052., 536400.,  716154.,
      725892.,  735630.,  745368.,  433932.,  440568., 447204.,  453840.,
      263336.,  268048.,  272760.,  277472.,  345868., 353080.,  360292.,
      367504.,  195432.,  200336.,  205240.,  210144., 669036.,  677304.,
      685572.,  693840.,  920634.,  933252.,  945870., 958488.,  554892.,
      563448.,  572004.,  580560.,  744876.,  754104., 763332.,  772560.,
      1022874., 1036932., 1050990., 1065048., 615372., 624888.,  634404.,
      643920.,  820716.,  830904.,  841092.,  851280., 1125114., 1140612.,
      1156110., 1171608., 675852.,  686328.,  696804., 707280.,  404136.,
      411408.,  418680.,  425952.,  526348.,  537400., 548452.,  559504.,
      295272.,  302736.,  310200.,  317664.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,   93444.,   94398.,   95352.,   112938.,  114180.,  115422.,
      116664.,  194730.,  197124.,  199518.,  201912.,  215178.,  217860.,
      220542.,  223224.,  296970.,  300804.,  304638.,  308472.,  317418.,
      321540.,  325662.,  329784.,  501450.,  508164.,  514878.,  521592.,
      521898.,  528900.,  535902.,  542904.,  603690.,  611844.,  619998.,
      628152.,  624138.,  632580.,  641022.,  649464.,  705930.,  715524.,
      725118.,  734712.,  726378.,  736260.,  746142.,  756024.,  910410.,
      922884.,  935358.,  947832.,  930858.,  943620.,  956382.,  969144.,
      1012650., 1026564., 1040478., 1054392., 1033098., 1047300., 1061502.,
      1075704., 1114890., 1130244., 1145598., 1160952., 1135338., 1150980.,
      1166622., 1182264.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  564.,  384.,  1014., 1104., 708.,  1554., 1644., 1032.,
      892.,  934.,  553.,  2634., 2724., 1680., 3174., 3264., 2004.,
      3714., 3804., 2328., 1900., 1942., 1129., 4794., 4884., 2976.,
      5334., 5424., 3300., 5874., 5964., 3624., 2908., 2950., 1705.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  564.,  1014., 1104., 1554., 1644., 2634., 2724., 3174.,
      3264., 3714., 3804., 4794., 4884., 5334., 5424., 5874., 5964.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,   948.,   1038., 1128.,  699.,  768.,  1848.,  2028.,  2010.,
      2208.,  1275.,  1416., 2820.,  3108., 2982., 3288.,  1851.,  2064.,
      1538.,  1784.,  1610., 1868.,  928.,  1106., 4764.,  5268.,  4926.,
      5448.,  3003.,  3360., 5736.,  6348., 5898., 6528.,  3579.,  4008.,
      6708.,  7428.,  6870., 7608.,  4155., 4656., 3266.,  3800.,  3338.,
      3884.,  1888.,  2258., 8652.,  9588., 8814., 9768.,  5307.,  5952.,
      9624.,  10668., 9786., 10848., 5883., 6600., 10596., 11748., 10758.,
      11928., 6459.,  7248., 4994.,  5816., 5066., 5900.,  2848.,  3410.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  1038.,  1128., 1848.,  2028.,  2010.,  2208.,  2820.,
      3108., 2982., 3288.,  4764., 5268.,  4926.,  5448.,  5736.,  6348.,
      5898., 6528., 6708.,  7428., 6870.,  7608.,  8652.,  9588.,  8814.,
      9768., 9624., 10668., 9786., 10848., 10596., 11748., 10758., 11928.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,  1329.,
      1398.,  1467.,  1536.,  3516.,  3696.,  3876.,  4056.,  3822.,  4020.,
      4218.,  4416.,  2409.,  2550.,  2691.,  2832.,  5352.,  5640.,  5928.,
      6216.,  5658.,  5964.,  6270.,  6576.,  3489.,  3702.,  3915.,  4128.,
      2830.,  3076.,  3322.,  3568.,  2962.,  3220.,  3478.,  3736.,  1678.,
      1856.,  2034.,  2212.,  9024.,  9528.,  10032., 10536., 9330.,  9852.,
      10374., 10896., 5649.,  6006.,  6363.,  6720.,  10860., 11472., 12084.,
      12696., 11166., 11796., 12426., 13056., 6729.,  7158.,  7587.,  8016.,
      12696., 13416., 14136., 14856., 13002., 13740., 14478., 15216., 7809.,
      8310.,  8811.,  9312.,  5998.,  6532.,  7066.,  7600.,  6130.,  6676.,
      7222.,  7768.,  3406.,  3776.,  4146.,  4516.,  16368., 17304., 18240.,
      19176., 16674., 17628., 18582., 19536., 9969.,  10614., 11259., 11904.,
      18204., 19248., 20292., 21336., 18510., 19572., 20634., 21696., 11049.,
      11766., 12483., 13200., 20040., 21192., 22344., 23496., 20346., 21516.,
      22686., 23856., 12129., 12918., 13707., 14496., 9166.,  9988.,  10810.,
      11632., 9298.,  10132., 10966., 11800., 5134.,  5696.,  6258.,  6820.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1986.,  2076.,  2166.,  2256.,  3516.,
      3696.,  3876.,  4056.,  3822.,  4020.,  4218.,  4416.,  5352.,  5640.,
      5928.,  6216.,  5658.,  5964.,  6270.,  6576.,  9024.,  9528.,  10032.,
      10536., 9330.,  9852.,  10374., 10896., 10860., 11472., 12084., 12696.,
      11166., 11796., 12426., 13056., 12696., 13416., 14136., 14856., 13002.,
      13740., 14478., 15216., 16368., 17304., 18240., 19176., 16674., 17628.,
      18582., 19536., 18204., 19248., 20292., 21336., 18510., 19572., 20634.,
      21696., 20040., 21192., 22344., 23496., 20346., 21516., 22686., 23856.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3567.,  4251.,  2886.,  7671.,  8355.,  5334.,  11775., 12459., 7782.,
      6608.,  6920.,  4048.,  19983., 20667., 12678., 24087., 24771., 15126.,
      28191., 28875., 17574., 14096., 14408., 8272.,  36399., 37083., 22470.,
      40503., 41187., 24918., 44607., 45291., 27366., 21584., 21896., 12496.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3567.,  4251.,  7671.,  8355.,  11775., 12459., 19983., 20667., 24087.,
      24771., 28191., 28875., 36399., 37083., 40503., 41187., 44607., 45291.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  8151.,  8502.,  5502.,  5772.,  14631., 15342., 15927.,
      16710., 10110., 10668., 22407., 23550., 23703., 24918., 14718., 15564.,
      12238., 13216., 12814., 13840., 7388.,  8096.,  37959., 39966., 39255.,
      41334., 23934., 25356., 45735., 48174., 47031., 49542., 28542., 30252.,
      53511., 56382., 54807., 57750., 33150., 35148., 26062., 28192., 26638.,
      28816., 15068., 16544., 69063., 72798., 70359., 74166., 42366., 44940.,
      76839., 81006., 78135., 82374., 46974., 49836., 84615., 89214., 85911.,
      90582., 51582., 54732., 39886., 43168., 40462., 43792., 22748., 24992.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  8151.,  8502.,  14631., 15342., 15927., 16710., 22407.,
      23550., 23703., 24918., 37959., 39966., 39255., 41334., 45735., 48174.,
      47031., 49542., 53511., 56382., 54807., 57750., 69063., 72798., 70359.,
      74166., 76839., 81006., 78135., 82374., 84615., 89214., 85911., 90582.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431.,  13710.,  13989.,  14268.,  15951.,  16302.,  16653.,  17004.,
      10734.,  11004.,  11274.,  11544.,  28551.,  29262.,  29973.,  30684.,
      31071.,  31854.,  32637.,  33420.,  19662.,  20220.,  20778.,  21336.,
      43671.,  44814.,  45957.,  47100.,  46191.,  47406.,  48621.,  49836.,
      28590.,  29436.,  30282.,  31128.,  23498.,  24476.,  25454.,  26432.,
      24602.,  25628.,  26654.,  27680.,  14068.,  14776.,  15484.,  16192.,
      73911.,  75918.,  77925.,  79932.,  76431.,  78510.,  80589.,  82668.,
      46446.,  47868.,  49290.,  50712.,  89031.,  91470.,  93909.,  96348.,
      91551.,  94062.,  96573.,  99084.,  55374.,  57084.,  58794.,  60504.,
      104151., 107022., 109893., 112764., 106671., 109614., 112557., 115500.,
      64302.,  66300.,  68298.,  70296.,  49994.,  52124.,  54254.,  56384.,
      51098.,  53276.,  55454.,  57632.,  28660.,  30136.,  31612.,  33088.,
      134391., 138126., 141861., 145596., 136911., 140718., 144525., 148332.,
      82158.,  84732.,  87306.,  89880.,  149511., 153678., 157845., 162012.,
      152031., 156270., 160509., 164748., 91086.,  93948.,  96810.,  99672.,
      164631., 169230., 173829., 178428., 167151., 171822., 176493., 181164.,
      100014., 103164., 106314., 109464., 76490.,  79772.,  83054.,  86336.,
      77594.,  80924.,  84254.,  87584.,  43252.,  45496.,  47740.,  49984.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431.,  13710.,  13989.,  14268.,  15951.,  16302.,  16653.,  17004.,
      28551.,  29262.,  29973.,  30684.,  31071.,  31854.,  32637.,  33420.,
      43671.,  44814.,  45957.,  47100.,  46191.,  47406.,  48621.,  49836.,
      73911.,  75918.,  77925.,  79932.,  76431.,  78510.,  80589.,  82668.,
      89031.,  91470.,  93909.,  96348.,  91551.,  94062.,  96573.,  99084.,
      104151., 107022., 109893., 112764., 106671., 109614., 112557., 115500.,
      134391., 138126., 141861., 145596., 136911., 140718., 144525., 148332.,
      149511., 153678., 157845., 162012., 152031., 156270., 160509., 164748.,
      164631., 169230., 173829., 178428., 167151., 171822., 176493., 181164.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27654.,  32982.,  22356.,  59622.,  64950.,  41364.,  91590.,  96918.,
      60372.,  50764.,  53164.,  30888.,  155526., 160854., 98388.,  187494.,
      192822., 117396., 219462., 224790., 136404., 108364., 110764., 63144.,
      283398., 288726., 174420., 315366., 320694., 193428., 347334., 352662.,
      212436., 165964., 168364., 95400.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27654.,  32982.,  59622.,  64950.,  91590.,  96918.,
      155526., 160854., 187494., 192822., 219462., 224790.,
      283398., 288726., 315366., 320694., 347334., 352662.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  64578.,  65964.,  43644.,  44712.,  116418., 119244.,
      126786., 129900., 80508.,  82728.,  178626., 183180., 188994., 193836.,
      117372., 120744., 97628.,  101528., 102236., 106328., 58952.,  61776.,
      303042., 311052., 313410., 321708., 191100., 196776., 365250., 374988.,
      375618., 385644., 227964., 234792., 427458., 438924., 437826., 449580.,
      264828., 272808., 208220., 216728., 212828., 221528., 120392., 126288.,
      551874., 566796., 562242., 577452., 338556., 348840., 614082., 630732.,
      624450., 641388., 375420., 386856., 676290., 694668., 686658., 705324.,
      412284., 424872., 318812., 331928., 323420., 336728., 181832., 190800.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  64578.,  65964.,  116418., 119244., 126786., 129900.,
      178626., 183180., 188994., 193836., 303042., 311052., 313410., 321708.,
      365250., 374988., 375618., 385644., 427458., 438924., 437826., 449580.,
      551874., 566796., 562242., 577452., 614082., 630732., 624450., 641388.,
      676290., 694668., 686658., 705324.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322.,  108420.,  109518.,  110616.,  127770.,  129156.,  130542.,
      131928.,  86220.,   87288.,   88356.,   89424.,   230010.,  232836.,
      235662.,  238488.,  250458.,  253572.,  256686.,  259800.,  158796.,
      161016.,  163236.,  165456.,  352698.,  357252.,  361806.,  366360.,
      373146.,  377988.,  382830.,  387672.,  231372.,  234744.,  238116.,
      241488.,  191356.,  195256.,  199156.,  203056.,  200380.,  204472.,
      208564.,  212656.,  115080.,  117904.,  120728.,  123552.,  598074.,
      606084.,  614094.,  622104.,  618522.,  626820.,  635118.,  643416.,
      376524.,  382200.,  387876.,  393552.,  720762.,  730500.,  740238.,
      749976.,  741210.,  751236.,  761262.,  771288.,  449100.,  455928.,
      462756.,  469584.,  843450.,  854916.,  866382.,  877848.,  863898.,
      875652.,  887406.,  899160.,  521676.,  529656.,  537636.,  545616.,
      407932.,  416440.,  424948.,  433456.,  416956.,  425656.,  434356.,
      443056.,  234888.,  240784.,  246680.,  252576.,  1088826., 1103748.,
      1118670., 1133592., 1109274., 1124484., 1139694., 1154904., 666828.,
      677112.,  687396.,  697680.,  1211514., 1228164., 1244814., 1261464.,
      1231962., 1248900., 1265838., 1282776., 739404.,  750840.,  762276.,
      773712.,  1334202., 1352580., 1370958., 1389336., 1354650., 1373316.,
      1391982., 1410648., 811980.,  824568.,  837156.,  849744.,  624508.,
      637624.,  650740.,  663856.,  633532.,  646840.,  660148.,  673456.,
      354696.,  363664.,  372632.,  381600.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322.,  108420.,  109518.,  110616.,  127770.,  129156.,  130542.,
      131928.,  230010.,  232836.,  235662.,  238488.,  250458.,  253572.,
      256686.,  259800.,  352698.,  357252.,  361806.,  366360.,  373146.,
      377988.,  382830.,  387672.,  598074.,  606084.,  614094.,  622104.,
      618522.,  626820.,  635118.,  643416.,  720762.,  730500.,  740238.,
      749976.,  741210.,  751236.,  761262.,  771288.,  843450.,  854916.,
      866382.,  877848.,  863898.,  875652.,  887406.,  899160.,  1088826.,
      1103748., 1118670., 1133592., 1109274., 1124484., 1139694., 1154904.,
      1211514., 1228164., 1244814., 1261464., 1231962., 1248900., 1265838.,
      1282776., 1334202., 1352580., 1370958., 1389336., 1354650., 1373316.,
      1391982., 1410648.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  516.,  1320., 1410., 1500., 948.,  2040., 2130.,
      2220., 1380., 1174., 1216., 1258., 739.,  3480., 3570., 3660., 2244.,
      4200., 4290., 4380., 2676., 4920., 5010., 5100., 3108., 2518., 2560.,
      2602., 1507., 6360., 6450., 6540., 3972., 7080., 7170., 7260., 4404.,
      7800., 7890., 7980., 4836., 3862., 3904., 3946., 2275.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      600.,  690.,  780.,  1320., 1410., 1500., 2040., 2130., 2220.,
      3480., 3570., 3660., 4200., 4290., 4380., 4920., 5010., 5100.,
      6360., 6450., 6540., 7080., 7170., 7260., 7800., 7890., 7980.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110.,  1200.,  1272.,  1380.,  1434.,  1560.,  939.,   1032., 2406.,
      2640.,  2568.,  2820.,  2730.,  3000.,  1707.,  1896.,  3702., 4080.,
      3864.,  4260.,  4026.,  4440.,  2475.,  2760.,  2024.,  2348., 2096.,
      2432.,  2168.,  2516.,  1240.,  1478.,  6294.,  6960.,  6456., 7140.,
      6618.,  7320.,  4011.,  4488.,  7590.,  8400.,  7752.,  8580., 7914.,
      8760.,  4779.,  5352.,  8886.,  9840.,  9048.,  10020., 9210., 10200.,
      5547.,  6216.,  4328.,  5036.,  4400.,  5120.,  4472.,  5204., 2520.,
      3014.,  11478., 12720., 11640., 12900., 11802., 13080., 7083., 7944.,
      12774., 14160., 12936., 14340., 13098., 14520., 7851.,  8808., 14070.,
      15600., 14232., 15780., 14394., 15960., 8619.,  9672.,  6632., 7724.,
      6704.,  7808.,  6776.,  7892.,  3800.,  4550.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1110.,  1200.,  1272.,  1380.,  1434.,  1560.,  2406.,  2640.,  2568.,
      2820.,  2730.,  3000.,  3702.,  4080.,  3864.,  4260.,  4026.,  4440.,
      6294.,  6960.,  6456.,  7140.,  6618.,  7320.,  7590.,  8400.,  7752.,
      8580.,  7914.,  8760.,  8886.,  9840.,  9048.,  10020., 9210.,  10200.,
      11478., 12720., 11640., 12900., 11802., 13080., 12774., 14160., 12936.,
      14340., 13098., 14520., 14070., 15600., 14232., 15780., 14394., 15960.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  1785.,  1878.,  1971.,  2064.,  4578.,  4812.,
      5046.,  5280.,  4884.,  5136.,  5388.,  5640.,  5190.,  5460.,  5730.,
      6000.,  3225.,  3414.,  3603.,  3792.,  7026.,  7404.,  7782.,  8160.,
      7332.,  7728.,  8124.,  8520.,  7638.,  8052.,  8466.,  8880.,  4665.,
      4950.,  5235.,  5520.,  3724.,  4048.,  4372.,  4696.,  3856.,  4192.,
      4528.,  4864.,  3988.,  4336.,  4684.,  5032.,  2242.,  2480.,  2718.,
      2956.,  11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280.,
      12534., 13236., 13938., 14640., 7545.,  8022.,  8499.,  8976.,  14370.,
      15180., 15990., 16800., 14676., 15504., 16332., 17160., 14982., 15828.,
      16674., 17520., 8985.,  9558.,  10131., 10704., 16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.,
      10425., 11094., 11763., 12432., 7948.,  8656.,  9364.,  10072., 8080.,
      8800.,  9520.,  10240., 8212.,  8944.,  9676.,  10408., 4546.,  5040.,
      5534.,  6028.,  21714., 22956., 24198., 25440., 22020., 23280., 24540.,
      25800., 22326., 23604., 24882., 26160., 13305., 14166., 15027., 15888.,
      24162., 25548., 26934., 28320., 24468., 25872., 27276., 28680., 24774.,
      26196., 27618., 29040., 14745., 15702., 16659., 17616., 26610., 28140.,
      29670., 31200., 26916., 28464., 30012., 31560., 27222., 28788., 30354.,
      31920., 16185., 17238., 18291., 19344., 12172., 13264., 14356., 15448.,
      12304., 13408., 14512., 15616., 12436., 13552., 14668., 15784., 6850.,
      7600.,  8350.,  9100.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2130.,  2220.,  2310.,  2400.,  2436.,  2544.,  2652.,  2760.,  2742.,
      2868.,  2994.,  3120.,  4578.,  4812.,  5046.,  5280.,  4884.,  5136.,
      5388.,  5640.,  5190.,  5460.,  5730.,  6000.,  7026.,  7404.,  7782.,
      8160.,  7332.,  7728.,  8124.,  8520.,  7638.,  8052.,  8466.,  8880.,
      11922., 12588., 13254., 13920., 12228., 12912., 13596., 14280., 12534.,
      13236., 13938., 14640., 14370., 15180., 15990., 16800., 14676., 15504.,
      16332., 17160., 14982., 15828., 16674., 17520., 16818., 17772., 18726.,
      19680., 17124., 18096., 19068., 20040., 17430., 18420., 19410., 20400.,
      21714., 22956., 24198., 25440., 22020., 23280., 24540., 25800., 22326.,
      23604., 24882., 26160., 24162., 25548., 26934., 28320., 24468., 25872.,
      27276., 28680., 24774., 26196., 27618., 29040., 26610., 28140., 29670.,
      31200., 26916., 28464., 30012., 31560., 27222., 28788., 30354., 31920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4539.,  5223.,  5907.,  3894.,  10011., 10695., 11379., 7158.,
      15483., 16167., 16851., 10422., 8708.,  9020.,  9332.,  5416.,
      26427., 27111., 27795., 16950., 31899., 32583., 33267., 20214.,
      37371., 38055., 38739., 23478., 18692., 19004., 19316., 11048.,
      48315., 48999., 49683., 30006., 53787., 54471., 55155., 33270.,
      59259., 59943., 60627., 36534., 28676., 28988., 29300., 16680.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4539.,  5223.,  5907.,  10011., 10695., 11379., 15483., 16167., 16851.,
      26427., 27111., 27795., 31899., 32583., 33267., 37371., 38055., 38739.,
      48315., 48999., 49683., 53787., 54471., 55155., 59259., 59943., 60627.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,   9078.,   10023.,  10446.,  11319.,  11814.,  7422.,  7788.,
      19095.,  20022.,  20391.,  21390.,  21687.,  22758.,  13566., 14316.,
      29463.,  30966.,  30759.,  32334.,  32055.,  33702.,  19710., 20844.,
      16126.,  17416.,  16702.,  18040.,  17278.,  18664.,  9884.,  10832.,
      50199.,  52854.,  51495.,  54222.,  52791.,  55590.,  31998., 33900.,
      60567.,  63798.,  61863.,  65166.,  63159.,  66534.,  38142., 40428.,
      70935.,  74742.,  72231.,  76110.,  73527.,  77478.,  44286., 46956.,
      34558.,  37384.,  35134.,  38008.,  35710.,  38632.,  20124., 22096.,
      91671.,  96630.,  92967.,  97998.,  94263.,  99366.,  56574., 60012.,
      102039., 107574., 103335., 108942., 104631., 110310., 62718., 66540.,
      112407., 118518., 113703., 119886., 114999., 121254., 68862., 73068.,
      52990.,  57352.,  53566.,  57976.,  54142.,  58600.,  30364., 33360.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8727.,   9078.,   10023.,  10446.,  11319.,  11814.,  19095.,  20022.,
      20391.,  21390.,  21687.,  22758.,  29463.,  30966.,  30759.,  32334.,
      32055.,  33702.,  50199.,  52854.,  51495.,  54222.,  52791.,  55590.,
      60567.,  63798.,  61863.,  65166.,  63159.,  66534.,  70935.,  74742.,
      72231.,  76110.,  73527.,  77478.,  91671.,  96630.,  92967.,  97998.,
      94263.,  99366.,  102039., 107574., 103335., 108942., 104631., 110310.,
      112407., 118518., 113703., 119886., 114999., 121254.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103.,  17454.,  17805.,  18156.,  19623.,  20046.,  20469.,  20892.,
      22143.,  22638.,  23133.,  23628.,  14478.,  14844.,  15210.,  15576.,
      37263.,  38190.,  39117.,  40044.,  39783.,  40782.,  41781.,  42780.,
      42303.,  43374.,  44445.,  45516.,  26382.,  27132.,  27882.,  28632.,
      57423.,  58926.,  60429.,  61932.,  59943.,  61518.,  63093.,  64668.,
      62463.,  64110.,  65757.,  67404.,  38286.,  39420.,  40554.,  41688.,
      30962.,  32252.,  33542.,  34832.,  32066.,  33404.,  34742.,  36080.,
      33170.,  34556.,  35942.,  37328.,  18820.,  19768.,  20716.,  21664.,
      97743.,  100398., 103053., 105708., 100263., 102990., 105717., 108444.,
      102783., 105582., 108381., 111180., 62094.,  63996.,  65898.,  67800.,
      117903., 121134., 124365., 127596., 120423., 123726., 127029., 130332.,
      122943., 126318., 129693., 133068., 73998.,  76284.,  78570.,  80856.,
      138063., 141870., 145677., 149484., 140583., 144462., 148341., 152220.,
      143103., 147054., 151005., 154956., 85902.,  88572.,  91242.,  93912.,
      66290.,  69116.,  71942.,  74768.,  67394.,  70268.,  73142.,  76016.,
      68498.,  71420.,  74342.,  77264.,  38276.,  40248.,  42220.,  44192.,
      178383., 183342., 188301., 193260., 180903., 185934., 190965., 195996.,
      183423., 188526., 193629., 198732., 109710., 113148., 116586., 120024.,
      198543., 204078., 209613., 215148., 201063., 206670., 212277., 217884.,
      203583., 209262., 214941., 220620., 121614., 125436., 129258., 133080.,
      218703., 224814., 230925., 237036., 221223., 227406., 233589., 239772.,
      223743., 229998., 236253., 242508., 133518., 137724., 141930., 146136.,
      101618., 105980., 110342., 114704., 102722., 107132., 111542., 115952.,
      103826., 108284., 112742., 117200., 57732.,  60728.,  63724.,  66720.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17103.,  17454.,  17805.,  18156.,  19623.,  20046.,  20469.,  20892.,
      22143.,  22638.,  23133.,  23628.,  37263.,  38190.,  39117.,  40044.,
      39783.,  40782.,  41781.,  42780.,  42303.,  43374.,  44445.,  45516.,
      57423.,  58926.,  60429.,  61932.,  59943.,  61518.,  63093.,  64668.,
      62463.,  64110.,  65757.,  67404.,  97743.,  100398., 103053., 105708.,
      100263., 102990., 105717., 108444., 102783., 105582., 108381., 111180.,
      117903., 121134., 124365., 127596., 120423., 123726., 127029., 130332.,
      122943., 126318., 129693., 133068., 138063., 141870., 145677., 149484.,
      140583., 144462., 148341., 152220., 143103., 147054., 151005., 154956.,
      178383., 183342., 188301., 193260., 180903., 185934., 190965., 195996.,
      183423., 188526., 193629., 198732., 198543., 204078., 209613., 215148.,
      201063., 206670., 212277., 217884., 203583., 209262., 214941., 220620.,
      218703., 224814., 230925., 237036., 221223., 227406., 233589., 239772.,
      223743., 229998., 236253., 242508.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35286.,  40614.,  45942.,  30228.,  77910.,  83238.,  88566.,  55572.,
      120534., 125862., 131190., 80916.,  66940.,  69340.,  71740.,  41352.,
      205782., 211110., 216438., 131604., 248406., 253734., 259062., 156948.,
      291030., 296358., 301686., 182292., 143740., 146140., 148540., 84360.,
      376278., 381606., 386934., 232980., 418902., 424230., 429558., 258324.,
      461526., 466854., 472182., 283668., 220540., 222940., 225340., 127368.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35286.,  40614.,  45942.,  77910.,  83238.,  88566.,  120534.,
      125862., 131190., 205782., 211110., 216438., 248406., 253734.,
      259062., 291030., 296358., 301686., 376278., 381606., 386934.,
      418902., 424230., 429558., 461526., 466854., 472182.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,  59004.,  60456.,
      152130., 155820., 162498., 166476., 172866., 177132., 108156., 111144.,
      235074., 241068., 245442., 251724., 255810., 262380., 157308., 161832.,
      128732., 133880., 133340., 138680., 137948., 143480., 78920.,  82704.,
      400962., 411564., 411330., 422220., 421698., 432876., 255612., 263208.,
      483906., 496812., 494274., 507468., 504642., 518124., 304764., 313896.,
      566850., 582060., 577218., 592716., 587586., 603372., 353916., 364584.,
      276188., 287480., 280796., 292280., 285404., 297080., 160840., 168720.,
      732738., 752556., 743106., 763212., 753474., 773868., 452220., 465960.,
      815682., 837804., 826050., 848460., 836418., 859116., 501372., 516648.,
      898626., 923052., 908994., 933708., 919362., 944364., 550524., 567336.,
      423644., 441080., 428252., 445880., 432860., 450680., 242760., 254736.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69186.,  70572.,  79554.,  81228.,  89922.,  91884.,  152130., 155820.,
      162498., 166476., 172866., 177132., 235074., 241068., 245442., 251724.,
      255810., 262380., 400962., 411564., 411330., 422220., 421698., 432876.,
      483906., 496812., 494274., 507468., 504642., 518124., 566850., 582060.,
      577218., 592716., 587586., 603372., 732738., 752556., 743106., 763212.,
      753474., 773868., 815682., 837804., 826050., 848460., 836418., 859116.,
      898626., 923052., 908994., 933708., 919362., 944364.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986.,  138372.,  139758.,  141144.,  157434.,  159108.,  160782.,
      162456.,  177882.,  179844.,  181806.,  183768.,  116556.,  118008.,
      119460.,  120912.,  300570.,  304260.,  307950.,  311640.,  321018.,
      324996.,  328974.,  332952.,  341466.,  345732.,  349998.,  354264.,
      213324.,  216312.,  219300.,  222288.,  464154.,  470148.,  476142.,
      482136.,  484602.,  490884.,  497166.,  503448.,  505050.,  511620.,
      518190.,  524760.,  310092.,  314616.,  319140.,  323664.,  252316.,
      257464.,  262612.,  267760.,  261340.,  266680.,  272020.,  277360.,
      270364.,  275896.,  281428.,  286960.,  154056.,  157840.,  161624.,
      165408.,  791322.,  801924.,  812526.,  823128.,  811770.,  822660.,
      833550.,  844440.,  832218.,  843396.,  854574.,  865752.,  503628.,
      511224.,  518820.,  526416.,  954906.,  967812.,  980718.,  993624.,
      975354.,  988548.,  1001742., 1014936., 995802.,  1009284., 1022766.,
      1036248., 600396.,  609528.,  618660.,  627792.,  1118490., 1133700.,
      1148910., 1164120., 1138938., 1154436., 1169934., 1185432., 1159386.,
      1175172., 1190958., 1206744., 697164.,  707832.,  718500.,  729168.,
      541084.,  552376.,  563668.,  574960.,  550108.,  561592.,  573076.,
      584560.,  559132.,  570808.,  582484.,  594160.,  313800.,  321680.,
      329560.,  337440.,  1445658., 1465476., 1485294., 1505112., 1466106.,
      1486212., 1506318., 1526424., 1486554., 1506948., 1527342., 1547736.,
      890700.,  904440.,  918180.,  931920.,  1609242., 1631364., 1653486.,
      1675608., 1629690., 1652100., 1674510., 1696920., 1650138., 1672836.,
      1695534., 1718232., 987468.,  1002744., 1018020., 1033296., 1772826.,
      1797252., 1821678., 1846104., 1793274., 1817988., 1842702., 1867416.,
      1813722., 1838724., 1863726., 1888728., 1084236., 1101048., 1117860.,
      1134672., 829852.,  847288.,  864724.,  882160.,  838876.,  856504.,
      874132.,  891760.,  847900.,  865720.,  883540.,  901360.,  473544.,
      485520.,  497496.,  509472.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride2, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136986.,  138372.,  139758.,  141144.,  157434.,  159108.,  160782.,
      162456.,  177882.,  179844.,  181806.,  183768.,  300570.,  304260.,
      307950.,  311640.,  321018.,  324996.,  328974.,  332952.,  341466.,
      345732.,  349998.,  354264.,  464154.,  470148.,  476142.,  482136.,
      484602.,  490884.,  497166.,  503448.,  505050.,  511620.,  518190.,
      524760.,  791322.,  801924.,  812526.,  823128.,  811770.,  822660.,
      833550.,  844440.,  832218.,  843396.,  854574.,  865752.,  954906.,
      967812.,  980718.,  993624.,  975354.,  988548.,  1001742., 1014936.,
      995802.,  1009284., 1022766., 1036248., 1118490., 1133700., 1148910.,
      1164120., 1138938., 1154436., 1169934., 1185432., 1159386., 1175172.,
      1190958., 1206744., 1445658., 1465476., 1485294., 1505112., 1466106.,
      1486212., 1506318., 1526424., 1486554., 1506948., 1527342., 1547736.,
      1609242., 1631364., 1653486., 1675608., 1629690., 1652100., 1674510.,
      1696920., 1650138., 1672836., 1695534., 1718232., 1772826., 1797252.,
      1821678., 1846104., 1793274., 1817988., 1842702., 1867416., 1813722.,
      1838724., 1863726., 1888728.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}